YES

We show the termination of the TRS R:

  active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
  active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
  active(U13(tt())) -> mark(tt())
  active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
  active(U22(tt())) -> mark(tt())
  active(U31(tt(),N)) -> mark(N)
  active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
  active(and(tt(),X)) -> mark(X)
  active(isNat(|0|())) -> mark(tt())
  active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
  active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
  active(isNatKind(|0|())) -> mark(tt())
  active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
  active(isNatKind(s(V1))) -> mark(isNatKind(V1))
  active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
  active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
  mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
  mark(tt()) -> active(tt())
  mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
  mark(isNat(X)) -> active(isNat(X))
  mark(U13(X)) -> active(U13(mark(X)))
  mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
  mark(U22(X)) -> active(U22(mark(X)))
  mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
  mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
  mark(s(X)) -> active(s(mark(X)))
  mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
  mark(and(X1,X2)) -> active(and(mark(X1),X2))
  mark(|0|()) -> active(|0|())
  mark(isNatKind(X)) -> active(isNatKind(X))
  U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
  U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
  U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
  U11(active(X1),X2,X3) -> U11(X1,X2,X3)
  U11(X1,active(X2),X3) -> U11(X1,X2,X3)
  U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
  U12(mark(X1),X2) -> U12(X1,X2)
  U12(X1,mark(X2)) -> U12(X1,X2)
  U12(active(X1),X2) -> U12(X1,X2)
  U12(X1,active(X2)) -> U12(X1,X2)
  isNat(mark(X)) -> isNat(X)
  isNat(active(X)) -> isNat(X)
  U13(mark(X)) -> U13(X)
  U13(active(X)) -> U13(X)
  U21(mark(X1),X2) -> U21(X1,X2)
  U21(X1,mark(X2)) -> U21(X1,X2)
  U21(active(X1),X2) -> U21(X1,X2)
  U21(X1,active(X2)) -> U21(X1,X2)
  U22(mark(X)) -> U22(X)
  U22(active(X)) -> U22(X)
  U31(mark(X1),X2) -> U31(X1,X2)
  U31(X1,mark(X2)) -> U31(X1,X2)
  U31(active(X1),X2) -> U31(X1,X2)
  U31(X1,active(X2)) -> U31(X1,X2)
  U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
  U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
  U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
  U41(active(X1),X2,X3) -> U41(X1,X2,X3)
  U41(X1,active(X2),X3) -> U41(X1,X2,X3)
  U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
  s(mark(X)) -> s(X)
  s(active(X)) -> s(X)
  plus(mark(X1),X2) -> plus(X1,X2)
  plus(X1,mark(X2)) -> plus(X1,X2)
  plus(active(X1),X2) -> plus(X1,X2)
  plus(X1,active(X2)) -> plus(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)
  isNatKind(mark(X)) -> isNatKind(X)
  isNatKind(active(X)) -> isNatKind(X)

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p4, p8, p12, p13, p16, p18, p23, p27, p31, p33, p38, p47, p49, p51, p53, p54, p55, p57, p58, p60, p61, p63, p64, p66, p67, p69, p70, p72, p73, p75, p76, p77, p79, p81}
  {p88, p89, p90, p91}
  {p92, p93}
  {p94, p95}
  {p100, p101}
  {p112, p113}
  {p114, p115, p116, p117}
  {p82, p83, p84, p85, p86, p87}
  {p118, p119, p120, p121}
  {p122, p123}
  {p96, p97, p98, p99}
  {p102, p103, p104, p105}
  {p106, p107, p108, p109, p110, p111}


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(plus(N,|0|())) -> mark#(U31(and(isNat(N),isNatKind(N)),N))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(s(X)) -> active#(s(mark(X)))
p13: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p14: mark#(U41(X1,X2,X3)) -> mark#(X1)
p15: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p16: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p17: mark#(U31(X1,X2)) -> mark#(X1)
p18: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p19: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p20: mark#(U22(X)) -> mark#(X)
p21: mark#(U22(X)) -> active#(U22(mark(X)))
p22: active#(and(tt(),X)) -> mark#(X)
p23: mark#(U21(X1,X2)) -> mark#(X1)
p24: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p25: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p26: mark#(U13(X)) -> mark#(X)
p27: mark#(U13(X)) -> active#(U13(mark(X)))
p28: active#(U31(tt(),N)) -> mark#(N)
p29: mark#(isNat(X)) -> active#(isNat(X))
p30: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p31: mark#(U12(X1,X2)) -> mark#(X1)
p32: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p33: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p34: mark#(U11(X1,X2,X3)) -> mark#(X1)
p35: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2,x3) = x1
          tt_A() = 0
          mark#_A(x1) = x1
          U12_A(x1,x2) = x1
          isNat_A(x1) = 0
          isNatKind_A(x1) = 0
          plus_A(x1,x2) = x1 + x2 + 1
          s_A(x1) = x1 + 1
          U41_A(x1,x2,x3) = x1 + x2 + x3 + 2
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          |0|_A() = 2
          U31_A(x1,x2) = x1 + x2 + 1
          U21_A(x1,x2) = x1
          U22_A(x1) = x1
          U13_A(x1) = x1
          active_A(x1) = x1
  
    precedence:
    
      active# = U11 = tt = mark# = isNatKind = s = U31 > U12 > plus = and = |0| > isNat = U41 = mark = U21 = U22 = U13 = active
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(plus) = []
      pi(s) = []
      pi(U41) = []
      pi(and) = []
      pi(mark) = []
      pi(|0|) = []
      pi(U31) = []
      pi(U21) = []
      pi(U22) = []
      pi(U13) = []
      pi(active) = []

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#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p9: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p10: mark#(s(X)) -> mark#(X)
p11: mark#(s(X)) -> active#(s(mark(X)))
p12: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p13: mark#(U41(X1,X2,X3)) -> mark#(X1)
p14: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p15: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p16: mark#(U31(X1,X2)) -> mark#(X1)
p17: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p18: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p19: mark#(U22(X)) -> mark#(X)
p20: mark#(U22(X)) -> active#(U22(mark(X)))
p21: active#(and(tt(),X)) -> mark#(X)
p22: mark#(U21(X1,X2)) -> mark#(X1)
p23: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p24: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p25: mark#(U13(X)) -> mark#(X)
p26: mark#(U13(X)) -> active#(U13(mark(X)))
p27: active#(U31(tt(),N)) -> mark#(N)
p28: mark#(isNat(X)) -> active#(isNat(X))
p29: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p30: mark#(U12(X1,X2)) -> mark#(X1)
p31: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p32: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p33: mark#(U11(X1,X2,X3)) -> mark#(X1)
p34: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34}


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(U31(tt(),N)) -> mark#(N)
p10: mark#(U13(X)) -> active#(U13(mark(X)))
p11: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p12: mark#(U13(X)) -> mark#(X)
p13: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p14: active#(and(tt(),X)) -> mark#(X)
p15: mark#(U21(X1,X2)) -> mark#(X1)
p16: mark#(U22(X)) -> active#(U22(mark(X)))
p17: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p18: mark#(U22(X)) -> mark#(X)
p19: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p20: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p21: mark#(U31(X1,X2)) -> mark#(X1)
p22: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p23: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p24: mark#(U41(X1,X2,X3)) -> mark#(X1)
p25: mark#(s(X)) -> active#(s(mark(X)))
p26: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p27: mark#(s(X)) -> mark#(X)
p28: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p29: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p30: mark#(plus(X1,X2)) -> mark#(X1)
p31: mark#(plus(X1,X2)) -> mark#(X2)
p32: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p33: mark#(and(X1,X2)) -> mark#(X1)
p34: mark#(isNatKind(X)) -> active#(isNatKind(X))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 2
          U11_A(x1,x2,x3) = 2
          tt_A() = 5
          mark#_A(x1) = 4
          U12_A(x1,x2) = 2
          isNat_A(x1) = 2
          mark_A(x1) = 3
          U13_A(x1) = 1
          U21_A(x1,x2) = 2
          U22_A(x1) = 1
          U31_A(x1,x2) = 2
          U41_A(x1,x2,x3) = 2
          s_A(x1) = 1
          plus_A(x1,x2) = 2
          and_A(x1,x2) = 2
          isNatKind_A(x1) = 2
          active_A(x1) = 3
          |0|_A() = 4
  
    precedence:
    
      tt = U12 = mark = U13 = U21 = s = and = isNatKind = active > active# = U11 = mark# = U22 = U41 = plus > isNat > U31 = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U13) = []
      pi(U21) = []
      pi(U22) = []
      pi(U31) = []
      pi(U41) = []
      pi(s) = []
      pi(plus) = []
      pi(and) = []
      pi(isNatKind) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p16

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(U31(tt(),N)) -> mark#(N)
p10: mark#(U13(X)) -> active#(U13(mark(X)))
p11: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p12: mark#(U13(X)) -> mark#(X)
p13: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p14: active#(and(tt(),X)) -> mark#(X)
p15: mark#(U21(X1,X2)) -> mark#(X1)
p16: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p17: mark#(U22(X)) -> mark#(X)
p18: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p19: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p20: mark#(U31(X1,X2)) -> mark#(X1)
p21: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p22: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p23: mark#(U41(X1,X2,X3)) -> mark#(X1)
p24: mark#(s(X)) -> active#(s(mark(X)))
p25: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p26: mark#(s(X)) -> mark#(X)
p27: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p28: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p29: mark#(plus(X1,X2)) -> mark#(X1)
p30: mark#(plus(X1,X2)) -> mark#(X2)
p31: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p32: mark#(and(X1,X2)) -> mark#(X1)
p33: mark#(isNatKind(X)) -> active#(isNatKind(X))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33}


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(s(X)) -> active#(s(mark(X)))
p13: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p14: mark#(U41(X1,X2,X3)) -> mark#(X1)
p15: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p16: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p17: mark#(U31(X1,X2)) -> mark#(X1)
p18: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p19: active#(and(tt(),X)) -> mark#(X)
p20: mark#(U22(X)) -> mark#(X)
p21: mark#(U21(X1,X2)) -> mark#(X1)
p22: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p23: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p24: mark#(U13(X)) -> mark#(X)
p25: mark#(U13(X)) -> active#(U13(mark(X)))
p26: active#(U31(tt(),N)) -> mark#(N)
p27: mark#(isNat(X)) -> active#(isNat(X))
p28: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p29: mark#(U12(X1,X2)) -> mark#(X1)
p30: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p31: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p32: mark#(U11(X1,X2,X3)) -> mark#(X1)
p33: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2,x3) = 1
          tt_A() = 0
          mark#_A(x1) = 1
          U12_A(x1,x2) = 1
          isNat_A(x1) = 1
          isNatKind_A(x1) = 1
          plus_A(x1,x2) = 1
          s_A(x1) = 1
          U41_A(x1,x2,x3) = 1
          and_A(x1,x2) = 1
          mark_A(x1) = 2
          U21_A(x1,x2) = 1
          U31_A(x1,x2) = 1
          U22_A(x1) = 0
          U13_A(x1) = 0
          active_A(x1) = 2
          |0|_A() = 0
  
    precedence:
    
      U13 = |0| > U11 = U12 = isNatKind = plus = U21 > tt = isNat > s = U41 = and > active# = mark# = mark = U22 = active > U31
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(plus) = []
      pi(s) = []
      pi(U41) = []
      pi(and) = []
      pi(mark) = []
      pi(U21) = []
      pi(U31) = []
      pi(U22) = []
      pi(U13) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p25

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(s(X)) -> active#(s(mark(X)))
p13: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p14: mark#(U41(X1,X2,X3)) -> mark#(X1)
p15: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p16: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p17: mark#(U31(X1,X2)) -> mark#(X1)
p18: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p19: active#(and(tt(),X)) -> mark#(X)
p20: mark#(U22(X)) -> mark#(X)
p21: mark#(U21(X1,X2)) -> mark#(X1)
p22: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p23: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p24: mark#(U13(X)) -> mark#(X)
p25: active#(U31(tt(),N)) -> mark#(N)
p26: mark#(isNat(X)) -> active#(isNat(X))
p27: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p28: mark#(U12(X1,X2)) -> mark#(X1)
p29: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p30: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p31: mark#(U11(X1,X2,X3)) -> mark#(X1)
p32: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(U31(tt(),N)) -> mark#(N)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p16: active#(and(tt(),X)) -> mark#(X)
p17: mark#(U31(X1,X2)) -> mark#(X1)
p18: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p19: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p20: mark#(U41(X1,X2,X3)) -> mark#(X1)
p21: mark#(s(X)) -> active#(s(mark(X)))
p22: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p23: mark#(s(X)) -> mark#(X)
p24: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p25: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p26: mark#(plus(X1,X2)) -> mark#(X1)
p27: mark#(plus(X1,X2)) -> mark#(X2)
p28: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p29: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p30: mark#(and(X1,X2)) -> mark#(X1)
p31: mark#(isNatKind(X)) -> active#(isNatKind(X))
p32: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          U11_A(x1,x2,x3) = 5
          tt_A() = 1
          mark#_A(x1) = 6
          U12_A(x1,x2) = 5
          isNat_A(x1) = 5
          mark_A(x1) = 3
          U13_A(x1) = 7
          U21_A(x1,x2) = 5
          U22_A(x1) = 2
          U31_A(x1,x2) = 5
          U41_A(x1,x2,x3) = 5
          s_A(x1) = 4
          plus_A(x1,x2) = 5
          and_A(x1,x2) = 5
          isNatKind_A(x1) = 5
          active_A(x1) = 3
          |0|_A() = 2
  
    precedence:
    
      s > active# = tt = mark# = U12 = isNat = mark = U13 = U22 = plus = and = active > U11 = U21 > U31 = U41 = isNatKind = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U13) = []
      pi(U21) = []
      pi(U22) = []
      pi(U31) = []
      pi(U41) = []
      pi(s) = []
      pi(plus) = []
      pi(and) = []
      pi(isNatKind) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p21

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(U31(tt(),N)) -> mark#(N)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p16: active#(and(tt(),X)) -> mark#(X)
p17: mark#(U31(X1,X2)) -> mark#(X1)
p18: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p19: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p20: mark#(U41(X1,X2,X3)) -> mark#(X1)
p21: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p22: mark#(s(X)) -> mark#(X)
p23: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p24: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p25: mark#(plus(X1,X2)) -> mark#(X1)
p26: mark#(plus(X1,X2)) -> mark#(X2)
p27: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p28: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p29: mark#(and(X1,X2)) -> mark#(X1)
p30: mark#(isNatKind(X)) -> active#(isNatKind(X))
p31: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(U41(X1,X2,X3)) -> mark#(X1)
p13: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p14: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p15: mark#(U31(X1,X2)) -> mark#(X1)
p16: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p17: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p18: mark#(U22(X)) -> mark#(X)
p19: mark#(U21(X1,X2)) -> mark#(X1)
p20: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p21: active#(and(tt(),X)) -> mark#(X)
p22: mark#(U13(X)) -> mark#(X)
p23: mark#(isNat(X)) -> active#(isNat(X))
p24: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p25: mark#(U12(X1,X2)) -> mark#(X1)
p26: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p27: active#(U31(tt(),N)) -> mark#(N)
p28: mark#(U11(X1,X2,X3)) -> mark#(X1)
p29: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p30: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p31: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          U11_A(x1,x2,x3) = x1
          tt_A() = 0
          mark#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1
          isNat_A(x1) = 0
          isNatKind_A(x1) = 0
          plus_A(x1,x2) = x1 + x2 + 2
          s_A(x1) = x1 + 2
          U41_A(x1,x2,x3) = x1 + x2 + x3 + 4
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          U21_A(x1,x2) = x1
          U31_A(x1,x2) = x1 + x2 + 2
          U22_A(x1) = x1
          U13_A(x1) = x1
          active_A(x1) = x1
          |0|_A() = 1
  
    precedence:
    
      U12 = isNatKind = plus = mark = U21 = U22 = active > U41 > tt = isNat = U31 = U13 = |0| > s > active# = U11 = mark# = and
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(plus) = []
      pi(s) = [1]
      pi(U41) = [1, 3]
      pi(and) = []
      pi(mark) = []
      pi(U21) = []
      pi(U31) = [2]
      pi(U22) = []
      pi(U13) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p27

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(U41(X1,X2,X3)) -> mark#(X1)
p13: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p14: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p15: mark#(U31(X1,X2)) -> mark#(X1)
p16: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p17: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p18: mark#(U22(X)) -> mark#(X)
p19: mark#(U21(X1,X2)) -> mark#(X1)
p20: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p21: active#(and(tt(),X)) -> mark#(X)
p22: mark#(U13(X)) -> mark#(X)
p23: mark#(isNat(X)) -> active#(isNat(X))
p24: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p25: mark#(U12(X1,X2)) -> mark#(X1)
p26: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p27: mark#(U11(X1,X2,X3)) -> mark#(X1)
p28: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p29: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p30: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(and(tt(),X)) -> mark#(X)
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p16: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p17: mark#(U31(X1,X2)) -> mark#(X1)
p18: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p19: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p20: mark#(U41(X1,X2,X3)) -> mark#(X1)
p21: mark#(s(X)) -> mark#(X)
p22: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p23: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p24: mark#(plus(X1,X2)) -> mark#(X1)
p25: mark#(plus(X1,X2)) -> mark#(X2)
p26: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p27: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p28: mark#(and(X1,X2)) -> mark#(X1)
p29: mark#(isNatKind(X)) -> active#(isNatKind(X))
p30: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 2
          U11_A(x1,x2,x3) = 2
          tt_A() = 5
          mark#_A(x1) = 4
          U12_A(x1,x2) = 2
          isNat_A(x1) = 2
          mark_A(x1) = 3
          U13_A(x1) = 1
          U21_A(x1,x2) = 2
          U22_A(x1) = 6
          U41_A(x1,x2,x3) = 2
          s_A(x1) = 2
          plus_A(x1,x2) = 2
          and_A(x1,x2) = 2
          U31_A(x1,x2) = 1
          isNatKind_A(x1) = 2
          active_A(x1) = 3
          |0|_A() = 6
  
    precedence:
    
      U12 > tt = isNat = mark = U13 = U21 = U22 = U41 = s = and = active > plus = U31 = |0| > active# = U11 = mark# > isNatKind
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U13) = []
      pi(U21) = []
      pi(U22) = []
      pi(U41) = []
      pi(s) = []
      pi(plus) = []
      pi(and) = []
      pi(U31) = []
      pi(isNatKind) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p15

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(and(tt(),X)) -> mark#(X)
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p16: mark#(U31(X1,X2)) -> mark#(X1)
p17: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p18: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p19: mark#(U41(X1,X2,X3)) -> mark#(X1)
p20: mark#(s(X)) -> mark#(X)
p21: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p22: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p23: mark#(plus(X1,X2)) -> mark#(X1)
p24: mark#(plus(X1,X2)) -> mark#(X2)
p25: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p26: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p27: mark#(and(X1,X2)) -> mark#(X1)
p28: mark#(isNatKind(X)) -> active#(isNatKind(X))
p29: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(U41(X1,X2,X3)) -> mark#(X1)
p13: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p14: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p15: mark#(U31(X1,X2)) -> mark#(X1)
p16: mark#(U22(X)) -> mark#(X)
p17: mark#(U21(X1,X2)) -> mark#(X1)
p18: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p19: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p20: mark#(U13(X)) -> mark#(X)
p21: mark#(isNat(X)) -> active#(isNat(X))
p22: active#(and(tt(),X)) -> mark#(X)
p23: mark#(U12(X1,X2)) -> mark#(X1)
p24: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p25: active#(U41(tt(),M,N)) -> mark#(s(plus(N,M)))
p26: mark#(U11(X1,X2,X3)) -> mark#(X1)
p27: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p28: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p29: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          U11_A(x1,x2,x3) = x1
          tt_A() = 0
          mark#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1
          isNat_A(x1) = 0
          isNatKind_A(x1) = 0
          plus_A(x1,x2) = x1 + x2 + 2
          s_A(x1) = x1 + 1
          U41_A(x1,x2,x3) = x1 + x2 + x3 + 3
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          U21_A(x1,x2) = x1
          U31_A(x1,x2) = x1 + x2 + 2
          U22_A(x1) = x1
          U13_A(x1) = x1
          active_A(x1) = x1
          |0|_A() = 0
  
    precedence:
    
      U11 = tt = U12 = isNat = isNatKind = plus = and = mark = U21 = U31 = U22 = U13 = active > U41 > active# = mark# = s = |0|
    
    partial status:
  
      pi(active#) = [1]
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = [1]
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(plus) = []
      pi(s) = [1]
      pi(U41) = [2]
      pi(and) = []
      pi(mark) = []
      pi(U21) = []
      pi(U31) = []
      pi(U22) = []
      pi(U13) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p25

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(U41(X1,X2,X3)) -> mark#(X1)
p13: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p14: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p15: mark#(U31(X1,X2)) -> mark#(X1)
p16: mark#(U22(X)) -> mark#(X)
p17: mark#(U21(X1,X2)) -> mark#(X1)
p18: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p19: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p20: mark#(U13(X)) -> mark#(X)
p21: mark#(isNat(X)) -> active#(isNat(X))
p22: active#(and(tt(),X)) -> mark#(X)
p23: mark#(U12(X1,X2)) -> mark#(X1)
p24: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p25: mark#(U11(X1,X2,X3)) -> mark#(X1)
p26: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p27: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p28: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(and(tt(),X)) -> mark#(X)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U31(X1,X2)) -> mark#(X1)
p16: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p17: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p18: mark#(U41(X1,X2,X3)) -> mark#(X1)
p19: mark#(s(X)) -> mark#(X)
p20: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p21: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p22: mark#(plus(X1,X2)) -> mark#(X1)
p23: mark#(plus(X1,X2)) -> mark#(X2)
p24: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p25: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p26: mark#(and(X1,X2)) -> mark#(X1)
p27: mark#(isNatKind(X)) -> active#(isNatKind(X))
p28: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          U11_A(x1,x2,x3) = x1
          tt_A() = 0
          mark#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1
          isNat_A(x1) = 0
          mark_A(x1) = x1
          U13_A(x1) = x1
          U21_A(x1,x2) = x1
          U22_A(x1) = x1
          and_A(x1,x2) = x1 + x2
          plus_A(x1,x2) = x1 + x2 + 2
          isNatKind_A(x1) = 0
          U31_A(x1,x2) = x1 + x2 + 2
          U41_A(x1,x2,x3) = x1 + x2 + x3 + 4
          s_A(x1) = x1 + 2
          active_A(x1) = x1
          |0|_A() = 1
  
    precedence:
    
      active# = U11 = tt = mark# = U12 = isNat = mark = U13 = U21 = U22 = and = plus = isNatKind = U31 = U41 = s = active = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U13) = []
      pi(U21) = []
      pi(U22) = []
      pi(and) = []
      pi(plus) = []
      pi(isNatKind) = []
      pi(U31) = []
      pi(U41) = []
      pi(s) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p15

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(and(tt(),X)) -> mark#(X)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p16: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p17: mark#(U41(X1,X2,X3)) -> mark#(X1)
p18: mark#(s(X)) -> mark#(X)
p19: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p20: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p21: mark#(plus(X1,X2)) -> mark#(X1)
p22: mark#(plus(X1,X2)) -> mark#(X2)
p23: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p24: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p25: mark#(and(X1,X2)) -> mark#(X1)
p26: mark#(isNatKind(X)) -> active#(isNatKind(X))
p27: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(plus(N,s(M))) -> mark#(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(U41(X1,X2,X3)) -> mark#(X1)
p13: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p14: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p15: mark#(U22(X)) -> mark#(X)
p16: mark#(U21(X1,X2)) -> mark#(X1)
p17: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p18: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p19: mark#(U13(X)) -> mark#(X)
p20: mark#(isNat(X)) -> active#(isNat(X))
p21: active#(and(tt(),X)) -> mark#(X)
p22: mark#(U12(X1,X2)) -> mark#(X1)
p23: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p24: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p25: mark#(U11(X1,X2,X3)) -> mark#(X1)
p26: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p27: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          U11_A(x1,x2,x3) = x1
          tt_A() = 0
          mark#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1
          isNat_A(x1) = 0
          isNatKind_A(x1) = 0
          plus_A(x1,x2) = x1 + x2 + 2
          s_A(x1) = x1 + 2
          U41_A(x1,x2,x3) = x1 + x2 + x3 + 4
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          U21_A(x1,x2) = x1
          U22_A(x1) = x1
          U13_A(x1) = x1
          active_A(x1) = x1
          U31_A(x1,x2) = x2 + 1
          |0|_A() = 2
  
    precedence:
    
      U11 = tt = U12 = isNat = isNatKind = plus = s = and = mark = U21 = U22 = U13 = active > U41 > active# = mark# = |0| > U31
    
    partial status:
  
      pi(active#) = [1]
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = [1]
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(plus) = []
      pi(s) = []
      pi(U41) = [2]
      pi(and) = []
      pi(mark) = []
      pi(U21) = []
      pi(U22) = []
      pi(U13) = []
      pi(active) = []
      pi(U31) = [2]
      pi(|0|) = []

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p9: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p10: mark#(s(X)) -> mark#(X)
p11: mark#(U41(X1,X2,X3)) -> mark#(X1)
p12: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p13: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U21(X1,X2)) -> mark#(X1)
p16: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p17: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p18: mark#(U13(X)) -> mark#(X)
p19: mark#(isNat(X)) -> active#(isNat(X))
p20: active#(and(tt(),X)) -> mark#(X)
p21: mark#(U12(X1,X2)) -> mark#(X1)
p22: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p23: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p24: mark#(U11(X1,X2,X3)) -> mark#(X1)
p25: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p26: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(and(tt(),X)) -> mark#(X)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p16: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p17: mark#(U41(X1,X2,X3)) -> mark#(X1)
p18: mark#(s(X)) -> mark#(X)
p19: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p20: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p21: mark#(plus(X1,X2)) -> mark#(X1)
p22: mark#(plus(X1,X2)) -> mark#(X2)
p23: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p24: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p25: mark#(and(X1,X2)) -> mark#(X1)
p26: mark#(isNatKind(X)) -> active#(isNatKind(X))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2,x3) = 5
          tt_A() = 6
          mark#_A(x1) = 5
          U12_A(x1,x2) = 5
          isNat_A(x1) = 5
          mark_A(x1) = 2
          U13_A(x1) = 7
          U21_A(x1,x2) = 5
          U22_A(x1) = 1
          and_A(x1,x2) = 5
          plus_A(x1,x2) = 4
          isNatKind_A(x1) = 5
          U41_A(x1,x2,x3) = 0
          s_A(x1) = 1
          active_A(x1) = 2
          U31_A(x1,x2) = 3
          |0|_A() = 1
  
    precedence:
    
      active# = U11 = tt = mark# = U12 = isNat = U21 = U22 = plus = isNatKind = |0| > and > mark = U13 = U41 = s = active = U31
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U13) = []
      pi(U21) = []
      pi(U22) = []
      pi(and) = []
      pi(plus) = []
      pi(isNatKind) = []
      pi(U41) = []
      pi(s) = []
      pi(active) = []
      pi(U31) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p19

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(and(tt(),X)) -> mark#(X)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p16: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p17: mark#(U41(X1,X2,X3)) -> mark#(X1)
p18: mark#(s(X)) -> mark#(X)
p19: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p20: mark#(plus(X1,X2)) -> mark#(X1)
p21: mark#(plus(X1,X2)) -> mark#(X2)
p22: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p23: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p24: mark#(and(X1,X2)) -> mark#(X1)
p25: mark#(isNatKind(X)) -> active#(isNatKind(X))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(s(X)) -> mark#(X)
p10: mark#(U41(X1,X2,X3)) -> mark#(X1)
p11: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U22(X)) -> mark#(X)
p14: mark#(U21(X1,X2)) -> mark#(X1)
p15: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p16: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p17: mark#(U13(X)) -> mark#(X)
p18: mark#(isNat(X)) -> active#(isNat(X))
p19: active#(and(tt(),X)) -> mark#(X)
p20: mark#(U12(X1,X2)) -> mark#(X1)
p21: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p22: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p23: mark#(U11(X1,X2,X3)) -> mark#(X1)
p24: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p25: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2,x3) = 5
          tt_A() = 2
          mark#_A(x1) = 5
          U12_A(x1,x2) = 5
          isNat_A(x1) = 5
          isNatKind_A(x1) = 5
          s_A(x1) = 6
          and_A(x1,x2) = 5
          mark_A(x1) = 3
          plus_A(x1,x2) = 6
          U41_A(x1,x2,x3) = 4
          U21_A(x1,x2) = 5
          U22_A(x1) = 1
          U13_A(x1) = 1
          active_A(x1) = 3
          U31_A(x1,x2) = 1
          |0|_A() = 6
  
    precedence:
    
      |0| > active# = U11 = tt = mark# = U12 = isNat = isNatKind = s = and = mark = plus = U41 = U21 = U22 = U13 = active = U31
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U41) = []
      pi(U21) = []
      pi(U22) = []
      pi(U13) = []
      pi(active) = []
      pi(U31) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p11

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(s(X)) -> mark#(X)
p10: mark#(U41(X1,X2,X3)) -> mark#(X1)
p11: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p12: mark#(U22(X)) -> mark#(X)
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p15: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p16: mark#(U13(X)) -> mark#(X)
p17: mark#(isNat(X)) -> active#(isNat(X))
p18: active#(and(tt(),X)) -> mark#(X)
p19: mark#(U12(X1,X2)) -> mark#(X1)
p20: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p21: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p22: mark#(U11(X1,X2,X3)) -> mark#(X1)
p23: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p24: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(and(tt(),X)) -> mark#(X)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(U41(X1,X2,X3)) -> mark#(X1)
p16: mark#(s(X)) -> mark#(X)
p17: mark#(plus(X1,X2)) -> mark#(X1)
p18: mark#(plus(X1,X2)) -> mark#(X2)
p19: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p20: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p21: mark#(and(X1,X2)) -> mark#(X1)
p22: mark#(isNatKind(X)) -> active#(isNatKind(X))
p23: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p24: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          U11_A(x1,x2,x3) = x1
          tt_A() = 0
          mark#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1
          isNat_A(x1) = 0
          mark_A(x1) = x1
          U13_A(x1) = x1
          U21_A(x1,x2) = x1
          U22_A(x1) = x1
          and_A(x1,x2) = x1 + x2
          plus_A(x1,x2) = x1 + x2 + 2
          isNatKind_A(x1) = 0
          U41_A(x1,x2,x3) = x1 + x2 + x3 + 4
          s_A(x1) = x1 + 2
          active_A(x1) = x1
          U31_A(x1,x2) = x2
          |0|_A() = 1
  
    precedence:
    
      U11 = tt = U12 = isNat = mark = U13 = U21 = U22 = and = isNatKind = active > active# = mark# = plus = U41 = s > U31 = |0|
    
    partial status:
  
      pi(active#) = [1]
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = [1]
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U13) = []
      pi(U21) = []
      pi(U22) = []
      pi(and) = []
      pi(plus) = [1]
      pi(isNatKind) = []
      pi(U41) = [1, 2, 3]
      pi(s) = [1]
      pi(active) = []
      pi(U31) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p15

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p3: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p4: mark#(U11(X1,X2,X3)) -> mark#(X1)
p5: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p6: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(and(tt(),X)) -> mark#(X)
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(s(X)) -> mark#(X)
p16: mark#(plus(X1,X2)) -> mark#(X1)
p17: mark#(plus(X1,X2)) -> mark#(X2)
p18: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p19: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p20: mark#(and(X1,X2)) -> mark#(X1)
p21: mark#(isNatKind(X)) -> active#(isNatKind(X))
p22: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p23: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V1,V2)) -> mark#(U12(isNat(V1),V2))
p2: mark#(isNatKind(X)) -> active#(isNatKind(X))
p3: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p4: mark#(and(X1,X2)) -> mark#(X1)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p7: mark#(plus(X1,X2)) -> mark#(X2)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(s(X)) -> mark#(X)
p10: mark#(U22(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> mark#(X1)
p12: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p13: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p14: mark#(U13(X)) -> mark#(X)
p15: mark#(isNat(X)) -> active#(isNat(X))
p16: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p17: mark#(U12(X1,X2)) -> mark#(X1)
p18: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p19: active#(and(tt(),X)) -> mark#(X)
p20: mark#(U11(X1,X2,X3)) -> mark#(X1)
p21: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p22: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p23: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2,x3) = x1 + x2 + x3 + 7
          tt_A() = 0
          mark#_A(x1) = x1
          U12_A(x1,x2) = x1 + x2 + 4
          isNat_A(x1) = x1 + 2
          isNatKind_A(x1) = 0
          s_A(x1) = x1 + 5
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + x2 + 8
          U22_A(x1) = x1 + 1
          U21_A(x1,x2) = x1 + x2 + 4
          U13_A(x1) = x1 + 1
          active_A(x1) = x1
          U31_A(x1,x2) = x2
          U41_A(x1,x2,x3) = x2 + x3 + 13
          |0|_A() = 1
  
    precedence:
    
      plus > isNatKind > s = and = U13 = U41 > active# = U11 = tt = mark# = U12 = isNat = mark = U22 = U21 = active = U31 = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(isNatKind) = []
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U22) = []
      pi(U21) = []
      pi(U13) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U13(X)) -> mark#(X)
p14: mark#(isNat(X)) -> active#(isNat(X))
p15: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p16: mark#(U12(X1,X2)) -> mark#(X1)
p17: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p18: active#(and(tt(),X)) -> mark#(X)
p19: mark#(U11(X1,X2,X3)) -> mark#(X1)
p20: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p21: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p22: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p4: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p5: mark#(U11(X1,X2,X3)) -> mark#(X1)
p6: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p7: active#(and(tt(),X)) -> mark#(X)
p8: mark#(U12(X1,X2)) -> mark#(X1)
p9: mark#(isNat(X)) -> active#(isNat(X))
p10: active#(isNat(plus(V1,V2))) -> mark#(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
p11: mark#(U13(X)) -> mark#(X)
p12: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p13: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p14: mark#(U21(X1,X2)) -> mark#(X1)
p15: mark#(U22(X)) -> mark#(X)
p16: mark#(s(X)) -> mark#(X)
p17: mark#(plus(X1,X2)) -> mark#(X1)
p18: mark#(plus(X1,X2)) -> mark#(X2)
p19: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p20: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p21: mark#(and(X1,X2)) -> mark#(X1)
p22: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1 + x2 + 7
          tt_A() = 0
          U13_A(x1) = x1 + 2
          isNat_A(x1) = x1 + 3
          U11_A(x1,x2,x3) = x1 + x2 + x3 + 11
          mark_A(x1) = x1
          U21_A(x1,x2) = x1 + x2 + 5
          U22_A(x1) = x1
          and_A(x1,x2) = x1 + x2
          plus_A(x1,x2) = x1 + x2 + 10
          s_A(x1) = x1 + 7
          active_A(x1) = x1
          U31_A(x1,x2) = x2 + 5
          U41_A(x1,x2,x3) = x2 + x3 + 17
          |0|_A() = 4
  
    precedence:
    
      isNatKind = U22 = and = U41 > s > tt = U13 = isNat = mark = active > mark# = active# > U12 = U11 > U21 > plus = U31 = |0|
    
    partial status:
  
      pi(mark#) = [1]
      pi(isNatKind) = []
      pi(active#) = [1]
      pi(U12) = []
      pi(tt) = []
      pi(U13) = []
      pi(isNat) = []
      pi(U11) = []
      pi(mark) = []
      pi(U21) = []
      pi(U22) = []
      pi(and) = []
      pi(plus) = []
      pi(s) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p10

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p4: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p5: mark#(U11(X1,X2,X3)) -> mark#(X1)
p6: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p7: active#(and(tt(),X)) -> mark#(X)
p8: mark#(U12(X1,X2)) -> mark#(X1)
p9: mark#(isNat(X)) -> active#(isNat(X))
p10: mark#(U13(X)) -> mark#(X)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U21(X1,X2)) -> mark#(X1)
p14: mark#(U22(X)) -> mark#(X)
p15: mark#(s(X)) -> mark#(X)
p16: mark#(plus(X1,X2)) -> mark#(X1)
p17: mark#(plus(X1,X2)) -> mark#(X2)
p18: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p19: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p20: mark#(and(X1,X2)) -> mark#(X1)
p21: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U13(X)) -> mark#(X)
p14: mark#(isNat(X)) -> active#(isNat(X))
p15: active#(and(tt(),X)) -> mark#(X)
p16: mark#(U12(X1,X2)) -> mark#(X1)
p17: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p18: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p19: mark#(U11(X1,X2,X3)) -> mark#(X1)
p20: mark#(U11(X1,X2,X3)) -> active#(U11(mark(X1),X2,X3))
p21: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = 6
          isNatKind_A(x1) = 2
          active#_A(x1) = x1 + 4
          s_A(x1) = 7
          and_A(x1,x2) = 2
          mark_A(x1) = 5
          plus_A(x1,x2) = 7
          U22_A(x1) = 3
          U21_A(x1,x2) = 2
          isNat_A(x1) = 2
          U13_A(x1) = 1
          tt_A() = 4
          U12_A(x1,x2) = 2
          U11_A(x1,x2,x3) = 1
          active_A(x1) = 5
          U31_A(x1,x2) = 1
          U41_A(x1,x2,x3) = 6
          |0|_A() = 6
  
    precedence:
    
      U31 > s = and = plus = U22 = U41 = |0| > mark# = active# = mark = U21 = U11 = active > isNatKind > isNat = U13 = tt = U12
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U22) = []
      pi(U21) = []
      pi(isNat) = []
      pi(U13) = []
      pi(tt) = []
      pi(U12) = []
      pi(U11) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p20

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U13(X)) -> mark#(X)
p14: mark#(isNat(X)) -> active#(isNat(X))
p15: active#(and(tt(),X)) -> mark#(X)
p16: mark#(U12(X1,X2)) -> mark#(X1)
p17: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p18: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p19: mark#(U11(X1,X2,X3)) -> mark#(X1)
p20: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: active#(U21(tt(),V1)) -> mark#(U22(isNat(V1)))
p6: mark#(U12(X1,X2)) -> mark#(X1)
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(and(tt(),X)) -> mark#(X)
p9: mark#(U13(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p11: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p12: mark#(U21(X1,X2)) -> mark#(X1)
p13: mark#(U22(X)) -> mark#(X)
p14: mark#(s(X)) -> mark#(X)
p15: mark#(plus(X1,X2)) -> mark#(X1)
p16: mark#(plus(X1,X2)) -> mark#(X2)
p17: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p18: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p19: mark#(and(X1,X2)) -> mark#(X1)
p20: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1
          U12_A(x1,x2) = x1 + x2 + 6
          tt_A() = 0
          U13_A(x1) = x1 + 1
          isNat_A(x1) = x1 + 4
          U11_A(x1,x2,x3) = x1 + x2 + x3 + 11
          mark_A(x1) = x1
          U21_A(x1,x2) = x1 + x2 + 6
          U22_A(x1) = x1 + 1
          and_A(x1,x2) = x1 + x2
          s_A(x1) = x1 + 7
          plus_A(x1,x2) = x1 + x2 + 12
          active_A(x1) = x1
          U31_A(x1,x2) = x2 + 2
          U41_A(x1,x2,x3) = x2 + x3 + 19
          |0|_A() = 1
  
    precedence:
    
      isNatKind = U12 = isNat = U11 = mark = U21 = U22 = s = plus = active = |0| > mark# = active# = tt = and > U13 > U31 = U41
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(U12) = []
      pi(tt) = []
      pi(U13) = []
      pi(isNat) = []
      pi(U11) = []
      pi(mark) = []
      pi(U21) = []
      pi(U22) = []
      pi(and) = []
      pi(s) = []
      pi(plus) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p5

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: mark#(U12(X1,X2)) -> mark#(X1)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: active#(and(tt(),X)) -> mark#(X)
p8: mark#(U13(X)) -> mark#(X)
p9: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p10: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p11: mark#(U21(X1,X2)) -> mark#(X1)
p12: mark#(U22(X)) -> mark#(X)
p13: mark#(s(X)) -> mark#(X)
p14: mark#(plus(X1,X2)) -> mark#(X1)
p15: mark#(plus(X1,X2)) -> mark#(X2)
p16: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p17: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p18: mark#(and(X1,X2)) -> mark#(X1)
p19: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U21(X1,X2)) -> active#(U21(mark(X1),X2))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U13(X)) -> mark#(X)
p14: mark#(isNat(X)) -> active#(isNat(X))
p15: active#(and(tt(),X)) -> mark#(X)
p16: mark#(U12(X1,X2)) -> mark#(X1)
p17: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p18: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p19: mark#(U11(X1,X2,X3)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = 8
          isNatKind_A(x1) = 7
          active#_A(x1) = x1 + 1
          s_A(x1) = 9
          and_A(x1,x2) = 7
          mark_A(x1) = 4
          plus_A(x1,x2) = 2
          U22_A(x1) = 5
          U21_A(x1,x2) = 6
          isNat_A(x1) = 7
          U13_A(x1) = 6
          tt_A() = 3
          U12_A(x1,x2) = 7
          U11_A(x1,x2,x3) = 8
          active_A(x1) = 4
          U31_A(x1,x2) = 1
          U41_A(x1,x2,x3) = 3
          |0|_A() = 8
  
    precedence:
    
      and > U21 > isNat > mark# = isNatKind = active# = s = mark = plus = U22 = U13 = tt = U12 = U11 = active = U31 = U41 = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U22) = []
      pi(U21) = []
      pi(isNat) = []
      pi(U13) = []
      pi(tt) = []
      pi(U12) = []
      pi(U11) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p11

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p12: mark#(U13(X)) -> mark#(X)
p13: mark#(isNat(X)) -> active#(isNat(X))
p14: active#(and(tt(),X)) -> mark#(X)
p15: mark#(U12(X1,X2)) -> mark#(X1)
p16: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p17: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p18: mark#(U11(X1,X2,X3)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: active#(and(tt(),X)) -> mark#(X)
p6: mark#(U12(X1,X2)) -> mark#(X1)
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p9: mark#(U13(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U22(X)) -> mark#(X)
p12: mark#(s(X)) -> mark#(X)
p13: mark#(plus(X1,X2)) -> mark#(X1)
p14: mark#(plus(X1,X2)) -> mark#(X2)
p15: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p16: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p17: mark#(and(X1,X2)) -> mark#(X1)
p18: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1 + 1
          U12_A(x1,x2) = x1 + x2 + 6
          tt_A() = 0
          U13_A(x1) = x1 + 2
          isNat_A(x1) = x1 + 2
          U11_A(x1,x2,x3) = x1 + x2 + x3 + 9
          mark_A(x1) = x1
          and_A(x1,x2) = x1 + x2
          s_A(x1) = x1
          U21_A(x1,x2) = x1 + x2 + 2
          U22_A(x1) = x1
          plus_A(x1,x2) = x1 + x2 + 10
          active_A(x1) = x1
          U31_A(x1,x2) = x2
          U41_A(x1,x2,x3) = x2 + x3 + 10
          |0|_A() = 1
  
    precedence:
    
      U12 = U13 = U22 > mark# = active# > isNatKind > U41 > tt = U11 = mark = and = plus = active > s = |0| > U31 > isNat = U21
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(U12) = []
      pi(tt) = []
      pi(U13) = []
      pi(isNat) = []
      pi(U11) = []
      pi(mark) = []
      pi(and) = []
      pi(s) = []
      pi(U21) = []
      pi(U22) = []
      pi(plus) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p9

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: active#(and(tt(),X)) -> mark#(X)
p6: mark#(U12(X1,X2)) -> mark#(X1)
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p9: mark#(U21(X1,X2)) -> mark#(X1)
p10: mark#(U22(X)) -> mark#(X)
p11: mark#(s(X)) -> mark#(X)
p12: mark#(plus(X1,X2)) -> mark#(X1)
p13: mark#(plus(X1,X2)) -> mark#(X2)
p14: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p15: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p16: mark#(and(X1,X2)) -> mark#(X1)
p17: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(isNat(X)) -> active#(isNat(X))
p12: active#(isNat(s(V1))) -> mark#(U21(isNatKind(V1),V1))
p13: mark#(U12(X1,X2)) -> mark#(X1)
p14: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p15: active#(and(tt(),X)) -> mark#(X)
p16: mark#(U11(X1,X2,X3)) -> mark#(X1)
p17: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1
          s_A(x1) = x1 + 7
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + x2 + 9
          U22_A(x1) = x1 + 1
          U21_A(x1,x2) = x1 + x2 + 5
          isNat_A(x1) = x1 + 3
          U12_A(x1,x2) = x1 + 4
          tt_A() = 0
          U11_A(x1,x2,x3) = x1 + x2 + 8
          U13_A(x1) = 1
          active_A(x1) = x1
          U31_A(x1,x2) = x2 + 1
          U41_A(x1,x2,x3) = x2 + x3 + 16
          |0|_A() = 2
  
    precedence:
    
      and = mark = U22 = U21 = U13 = active > U12 > U11 = |0| > U31 > mark# = isNatKind = active# = s = plus = isNat = tt = U41
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(s) = [1]
      pi(and) = []
      pi(mark) = []
      pi(plus) = [1, 2]
      pi(U22) = []
      pi(U21) = []
      pi(isNat) = []
      pi(U12) = [1]
      pi(tt) = []
      pi(U11) = [1, 2]
      pi(U13) = []
      pi(active) = []
      pi(U31) = [2]
      pi(U41) = [3]
      pi(|0|) = []

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: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(isNat(X)) -> active#(isNat(X))
p12: mark#(U12(X1,X2)) -> mark#(X1)
p13: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p14: active#(and(tt(),X)) -> mark#(X)
p15: mark#(U11(X1,X2,X3)) -> mark#(X1)
p16: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: active#(and(tt(),X)) -> mark#(X)
p6: mark#(U12(X1,X2)) -> mark#(X1)
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p9: mark#(U21(X1,X2)) -> mark#(X1)
p10: mark#(U22(X)) -> mark#(X)
p11: mark#(s(X)) -> mark#(X)
p12: mark#(plus(X1,X2)) -> mark#(X1)
p13: mark#(plus(X1,X2)) -> mark#(X2)
p14: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p15: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p16: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = 2
          isNatKind_A(x1) = 2
          active#_A(x1) = x1
          U12_A(x1,x2) = 2
          tt_A() = 0
          U13_A(x1) = 1
          isNat_A(x1) = 0
          U11_A(x1,x2,x3) = 3
          mark_A(x1) = 0
          and_A(x1,x2) = 2
          plus_A(x1,x2) = 4
          U21_A(x1,x2) = 4
          U22_A(x1) = 3
          s_A(x1) = 5
          active_A(x1) = 0
          U31_A(x1,x2) = 1
          U41_A(x1,x2,x3) = 3
          |0|_A() = 0
  
    precedence:
    
      U31 > mark# = active# = U12 = tt = U13 = isNat = mark = and = plus = U21 = U22 = s = active = U41 > isNatKind > U11 = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(U12) = []
      pi(tt) = []
      pi(U13) = []
      pi(isNat) = []
      pi(U11) = []
      pi(mark) = []
      pi(and) = []
      pi(plus) = []
      pi(U21) = []
      pi(U22) = []
      pi(s) = []
      pi(active) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: active#(and(tt(),X)) -> mark#(X)
p6: mark#(U12(X1,X2)) -> mark#(X1)
p7: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p8: mark#(U21(X1,X2)) -> mark#(X1)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(s(X)) -> mark#(X)
p11: mark#(plus(X1,X2)) -> mark#(X1)
p12: mark#(plus(X1,X2)) -> mark#(X2)
p13: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p14: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p15: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U12(X1,X2)) -> mark#(X1)
p12: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p13: active#(and(tt(),X)) -> mark#(X)
p14: mark#(U11(X1,X2,X3)) -> mark#(X1)
p15: active#(U12(tt(),V2)) -> mark#(U13(isNat(V2)))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1 + 1
          s_A(x1) = x1 + 9
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + x2
          U22_A(x1) = x1 + 2
          U21_A(x1,x2) = x1 + x2 + 8
          U12_A(x1,x2) = x1
          tt_A() = 0
          U11_A(x1,x2,x3) = x1 + x2 + 5
          U13_A(x1) = 0
          isNat_A(x1) = x1 + 5
          active_A(x1) = x1
          U31_A(x1,x2) = x2 + 1
          U41_A(x1,x2,x3) = x2 + x3 + 9
          |0|_A() = 1
  
    precedence:
    
      isNatKind = and = mark = plus = U12 = tt = active = U41 = |0| > mark# = active# > s = U22 = U21 = U13 = isNat = U31 > U11
    
    partial status:
  
      pi(mark#) = [1]
      pi(isNatKind) = []
      pi(active#) = [1]
      pi(s) = [1]
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U22) = [1]
      pi(U21) = [1]
      pi(U12) = []
      pi(tt) = []
      pi(U11) = []
      pi(U13) = []
      pi(isNat) = []
      pi(active) = []
      pi(U31) = [2]
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p15

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U12(X1,X2)) -> mark#(X1)
p12: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p13: active#(and(tt(),X)) -> mark#(X)
p14: mark#(U11(X1,X2,X3)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> active#(U12(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(U12(X1,X2)) -> mark#(X1)
p7: mark#(U21(X1,X2)) -> mark#(X1)
p8: mark#(U22(X)) -> mark#(X)
p9: mark#(s(X)) -> mark#(X)
p10: mark#(plus(X1,X2)) -> mark#(X1)
p11: mark#(plus(X1,X2)) -> mark#(X2)
p12: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p13: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p14: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = 4
          isNatKind_A(x1) = 4
          active#_A(x1) = x1
          and_A(x1,x2) = 4
          tt_A() = 6
          U11_A(x1,x2,x3) = 1
          U12_A(x1,x2) = 3
          mark_A(x1) = 7
          plus_A(x1,x2) = 3
          U21_A(x1,x2) = 7
          U22_A(x1) = 5
          s_A(x1) = 9
          active_A(x1) = 7
          isNat_A(x1) = 2
          U13_A(x1) = 8
          U31_A(x1,x2) = 8
          U41_A(x1,x2,x3) = 8
          |0|_A() = 0
  
    precedence:
    
      mark# = isNatKind = active# = and > tt = U11 = mark = plus = U21 = U22 = s = active = U13 = U31 = U41 > U12 = isNat = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(and) = []
      pi(tt) = []
      pi(U11) = []
      pi(U12) = []
      pi(mark) = []
      pi(plus) = []
      pi(U21) = []
      pi(U22) = []
      pi(s) = []
      pi(active) = []
      pi(isNat) = []
      pi(U13) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p5: mark#(U12(X1,X2)) -> mark#(X1)
p6: mark#(U21(X1,X2)) -> mark#(X1)
p7: mark#(U22(X)) -> mark#(X)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(plus(X1,X2)) -> mark#(X1)
p10: mark#(plus(X1,X2)) -> mark#(X2)
p11: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p12: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p13: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X2)
p7: mark#(plus(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)
p9: mark#(U22(X)) -> mark#(X)
p10: mark#(U21(X1,X2)) -> mark#(X1)
p11: mark#(U12(X1,X2)) -> mark#(X1)
p12: mark#(U11(X1,X2,X3)) -> mark#(X1)
p13: active#(and(tt(),X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1 + 1
          s_A(x1) = x1 + 4
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + x2 + 13
          U22_A(x1) = x1 + 2
          U21_A(x1,x2) = x1 + x2 + 12
          U12_A(x1,x2) = x1 + 2
          U11_A(x1,x2,x3) = x1 + x2 + x3 + 12
          tt_A() = 0
          active_A(x1) = x1
          isNat_A(x1) = x1 + 9
          U13_A(x1) = 0
          U31_A(x1,x2) = x2 + 2
          U41_A(x1,x2,x3) = x2 + x3 + 17
          |0|_A() = 1
  
    precedence:
    
      isNatKind = and = mark = plus = U21 = U12 = tt = active = U31 = U41 > U22 = isNat = U13 > mark# = active# = |0| > s = U11
    
    partial status:
  
      pi(mark#) = [1]
      pi(isNatKind) = []
      pi(active#) = [1]
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U22) = [1]
      pi(U21) = []
      pi(U12) = []
      pi(U11) = [1, 3]
      pi(tt) = []
      pi(active) = []
      pi(isNat) = [1]
      pi(U13) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(plus(X1,X2)) -> mark#(X1)
p7: mark#(s(X)) -> mark#(X)
p8: mark#(U22(X)) -> mark#(X)
p9: mark#(U21(X1,X2)) -> mark#(X1)
p10: mark#(U12(X1,X2)) -> mark#(X1)
p11: mark#(U11(X1,X2,X3)) -> mark#(X1)
p12: active#(and(tt(),X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> mark#(X1)
p5: mark#(U21(X1,X2)) -> mark#(X1)
p6: mark#(U22(X)) -> mark#(X)
p7: mark#(s(X)) -> mark#(X)
p8: mark#(plus(X1,X2)) -> mark#(X1)
p9: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p10: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p11: mark#(and(X1,X2)) -> mark#(X1)
p12: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 5
          isNatKind_A(x1) = 0
          active#_A(x1) = x1 + 5
          and_A(x1,x2) = x1 + x2
          tt_A() = 0
          U11_A(x1,x2,x3) = x1 + x2 + 11
          U12_A(x1,x2) = x1 + 6
          U21_A(x1,x2) = x1 + x2 + 7
          U22_A(x1) = x1 + 1
          s_A(x1) = x1 + 3
          plus_A(x1,x2) = x1 + x2 + 6
          mark_A(x1) = x1
          active_A(x1) = x1
          isNat_A(x1) = x1 + 5
          U13_A(x1) = 0
          U31_A(x1,x2) = x2 + 6
          U41_A(x1,x2,x3) = x2 + x3 + 9
          |0|_A() = 0
  
    precedence:
    
      and = mark = active = U31 = U41 > tt > mark# = active# = U11 = U22 > U12 = U21 > s > isNatKind = plus > U13 > isNat = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(and) = []
      pi(tt) = []
      pi(U11) = [1, 2]
      pi(U12) = [1]
      pi(U21) = [1, 2]
      pi(U22) = [1]
      pi(s) = []
      pi(plus) = [1]
      pi(mark) = []
      pi(active) = []
      pi(isNat) = [1]
      pi(U13) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

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: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> mark#(X1)
p5: mark#(U21(X1,X2)) -> mark#(X1)
p6: mark#(U22(X)) -> mark#(X)
p7: mark#(s(X)) -> mark#(X)
p8: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p9: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p10: mark#(and(X1,X2)) -> mark#(X1)
p11: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U22(X)) -> mark#(X)
p8: mark#(U21(X1,X2)) -> mark#(X1)
p9: mark#(U12(X1,X2)) -> mark#(X1)
p10: mark#(U11(X1,X2,X3)) -> mark#(X1)
p11: active#(and(tt(),X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1
          s_A(x1) = x1 + 5
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + x2
          U22_A(x1) = x1 + 1
          U21_A(x1,x2) = x1 + x2 + 6
          U12_A(x1,x2) = x1
          U11_A(x1,x2,x3) = x1 + x2 + 2
          tt_A() = 0
          active_A(x1) = x1
          isNat_A(x1) = x1 + 2
          U13_A(x1) = 0
          U31_A(x1,x2) = x2 + 1
          U41_A(x1,x2,x3) = x2 + x3 + 5
          |0|_A() = 3
  
    precedence:
    
      isNatKind = s = mark = plus = U12 = tt = active = U41 > U21 = U13 = U31 > mark# = active# = and = U22 = U11 = isNat = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = []
      pi(U22) = [1]
      pi(U21) = [1, 2]
      pi(U12) = []
      pi(U11) = [1]
      pi(tt) = []
      pi(active) = []
      pi(isNat) = [1]
      pi(U13) = []
      pi(U31) = [2]
      pi(U41) = []
      pi(|0|) = []

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: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U22(X)) -> mark#(X)
p8: mark#(U12(X1,X2)) -> mark#(X1)
p9: mark#(U11(X1,X2,X3)) -> mark#(X1)
p10: active#(and(tt(),X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U11(X1,X2,X3)) -> mark#(X1)
p4: mark#(U12(X1,X2)) -> mark#(X1)
p5: mark#(U22(X)) -> mark#(X)
p6: mark#(s(X)) -> mark#(X)
p7: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p8: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p9: mark#(and(X1,X2)) -> mark#(X1)
p10: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 1
          isNatKind_A(x1) = 0
          active#_A(x1) = x1 + 1
          and_A(x1,x2) = x1 + x2
          tt_A() = 0
          U11_A(x1,x2,x3) = x1 + x2 + 6
          U12_A(x1,x2) = x1 + 2
          U22_A(x1) = x1
          s_A(x1) = x1
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + 7
          active_A(x1) = x1
          isNat_A(x1) = x1 + 3
          U13_A(x1) = 2
          U21_A(x1,x2) = x2 + 3
          U31_A(x1,x2) = x2
          U41_A(x1,x2,x3) = x3 + 7
          |0|_A() = 1
  
    precedence:
    
      isNatKind = and = U22 = s = mark = plus = active = isNat > mark# = active# > tt = U11 = U12 > U13 = U21 = U31 = U41 = |0|
    
    partial status:
  
      pi(mark#) = [1]
      pi(isNatKind) = []
      pi(active#) = [1]
      pi(and) = []
      pi(tt) = []
      pi(U11) = [1]
      pi(U12) = [1]
      pi(U22) = []
      pi(s) = []
      pi(mark) = []
      pi(plus) = []
      pi(active) = []
      pi(isNat) = []
      pi(U13) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U12(X1,X2)) -> mark#(X1)
p4: mark#(U22(X)) -> mark#(X)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p7: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p8: mark#(and(X1,X2)) -> mark#(X1)
p9: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: active#(isNatKind(plus(V1,V2))) -> mark#(and(isNatKind(V1),isNatKind(V2)))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U22(X)) -> mark#(X)
p8: mark#(U12(X1,X2)) -> mark#(X1)
p9: active#(and(tt(),X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          isNatKind_A(x1) = x1
          active#_A(x1) = x1
          s_A(x1) = x1
          and_A(x1,x2) = x1 + x2
          mark_A(x1) = x1
          plus_A(x1,x2) = x1 + x2 + 7
          U22_A(x1) = x1
          U12_A(x1,x2) = x1 + 2
          tt_A() = 0
          active_A(x1) = x1
          U11_A(x1,x2,x3) = x2 + 6
          isNat_A(x1) = x1 + 3
          U13_A(x1) = 1
          U21_A(x1,x2) = x2 + 3
          U31_A(x1,x2) = x2 + 1
          U41_A(x1,x2,x3) = x2 + x3 + 7
          |0|_A() = 0
  
    precedence:
    
      isNatKind = s = mark = U22 = U12 = tt = active = U11 = isNat = U13 = U21 = U31 = U41 > plus > and = |0| > mark# = active#
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(s) = []
      pi(and) = []
      pi(mark) = []
      pi(plus) = [2]
      pi(U22) = []
      pi(U12) = []
      pi(tt) = []
      pi(active) = []
      pi(U11) = []
      pi(isNat) = []
      pi(U13) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p5

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(U22(X)) -> mark#(X)
p7: mark#(U12(X1,X2)) -> mark#(X1)
p8: active#(and(tt(),X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U12(X1,X2)) -> mark#(X1)
p4: mark#(U22(X)) -> mark#(X)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p7: active#(isNatKind(s(V1))) -> mark#(isNatKind(V1))
p8: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + 2
          isNatKind_A(x1) = x1 + 8
          active#_A(x1) = x1 + 1
          and_A(x1,x2) = x1 + x2 + 3
          tt_A() = 20
          U12_A(x1,x2) = x1 + 19
          U22_A(x1) = x1 + 3
          s_A(x1) = x1 + 7
          mark_A(x1) = x1
          active_A(x1) = x1
          U11_A(x1,x2,x3) = x2 + x3 + 22
          isNat_A(x1) = x1 + 2
          U13_A(x1) = 21
          U21_A(x1,x2) = x2 + 6
          U31_A(x1,x2) = x2
          U41_A(x1,x2,x3) = x2 + x3 + 30
          plus_A(x1,x2) = x1 + x2 + 23
          |0|_A() = 21
  
    precedence:
    
      and = mark = active = U13 = U31 = plus > tt = U12 = U22 = U11 = U41 = |0| > mark# = isNatKind = active# = s = isNat = U21
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = [1]
      pi(and) = []
      pi(tt) = []
      pi(U12) = [1]
      pi(U22) = [1]
      pi(s) = [1]
      pi(mark) = []
      pi(active) = []
      pi(U11) = []
      pi(isNat) = []
      pi(U13) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = [2, 3]
      pi(plus) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(U12(X1,X2)) -> mark#(X1)
p4: mark#(U22(X)) -> mark#(X)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p7: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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: mark#(isNatKind(X)) -> active#(isNatKind(X))
p2: active#(and(tt(),X)) -> mark#(X)
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(U22(X)) -> mark#(X)
p7: mark#(U12(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = 5
          isNatKind_A(x1) = 3
          active#_A(x1) = x1 + 1
          and_A(x1,x2) = 4
          tt_A() = 7
          mark_A(x1) = 8
          s_A(x1) = 6
          U22_A(x1) = 6
          U12_A(x1,x2) = 6
          active_A(x1) = 8
          U11_A(x1,x2,x3) = 1
          isNat_A(x1) = 2
          U13_A(x1) = 9
          U21_A(x1,x2) = 9
          U31_A(x1,x2) = 7
          U41_A(x1,x2,x3) = 5
          plus_A(x1,x2) = 9
          |0|_A() = 5
  
    precedence:
    
      mark# = active# = and = s > isNatKind = tt = mark = U22 = U12 = active = U11 = isNat = U13 = U21 = U31 = U41 = plus = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(isNatKind) = []
      pi(active#) = []
      pi(and) = []
      pi(tt) = []
      pi(mark) = []
      pi(s) = []
      pi(U22) = []
      pi(U12) = []
      pi(active) = []
      pi(U11) = []
      pi(isNat) = []
      pi(U13) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(plus) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(and(tt(),X)) -> mark#(X)
p2: mark#(and(X1,X2)) -> mark#(X1)
p3: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p4: mark#(s(X)) -> mark#(X)
p5: mark#(U22(X)) -> mark#(X)
p6: mark#(U12(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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: active#(and(tt(),X)) -> mark#(X)
p2: mark#(U12(X1,X2)) -> mark#(X1)
p3: mark#(U22(X)) -> mark#(X)
p4: mark#(s(X)) -> mark#(X)
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p6: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + 1
          and_A(x1,x2) = x1 + x2 + 3
          tt_A() = 15
          mark#_A(x1) = x1 + 2
          U12_A(x1,x2) = x1 + 4
          U22_A(x1) = x1 + 3
          s_A(x1) = x1 + 9
          mark_A(x1) = x1
          active_A(x1) = x1
          U11_A(x1,x2,x3) = x2 + x3 + 16
          isNat_A(x1) = x1 + 11
          U13_A(x1) = 16
          U21_A(x1,x2) = x2 + 15
          U31_A(x1,x2) = x2 + 19
          U41_A(x1,x2,x3) = x2 + x3 + 21
          plus_A(x1,x2) = x1 + x2 + 12
          |0|_A() = 7
          isNatKind_A(x1) = x1 + 8
  
    precedence:
    
      tt = mark = active = U11 = U41 = plus = |0| = isNatKind > U12 > active# = and = mark# = U22 = s = isNat = U13 > U21 > U31
    
    partial status:
  
      pi(active#) = [1]
      pi(and) = []
      pi(tt) = []
      pi(mark#) = [1]
      pi(U12) = [1]
      pi(U22) = [1]
      pi(s) = [1]
      pi(mark) = []
      pi(active) = []
      pi(U11) = []
      pi(isNat) = [1]
      pi(U13) = []
      pi(U21) = [2]
      pi(U31) = []
      pi(U41) = []
      pi(plus) = []
      pi(|0|) = []
      pi(isNatKind) = []

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(U12(X1,X2)) -> mark#(X1)
p2: mark#(U22(X)) -> mark#(X)
p3: mark#(s(X)) -> mark#(X)
p4: mark#(and(X1,X2)) -> active#(and(mark(X1),X2))
p5: mark#(and(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p5}


-- Reduction pair.

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

p1: mark#(U12(X1,X2)) -> mark#(X1)
p2: mark#(and(X1,X2)) -> mark#(X1)
p3: mark#(s(X)) -> mark#(X)
p4: mark#(U22(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          U12_A(x1,x2) = x1 + x2 + 1
          and_A(x1,x2) = x1 + x2 + 1
          s_A(x1) = x1 + 1
          U22_A(x1) = x1 + 1
  
    precedence:
    
      mark# = and = s > U12 = U22
    
    partial status:
  
      pi(mark#) = [1]
      pi(U12) = [1, 2]
      pi(and) = [1, 2]
      pi(s) = [1]
      pi(U22) = []

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(and(X1,X2)) -> mark#(X1)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(U22(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: mark#(and(X1,X2)) -> mark#(X1)
p2: mark#(U22(X)) -> mark#(X)
p3: mark#(s(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          and_A(x1,x2) = x1 + x2 + 1
          U22_A(x1) = x1 + 1
          s_A(x1) = x1 + 1
  
    precedence:
    
      mark# = and = U22 = s
    
    partial status:
  
      pi(mark#) = [1]
      pi(and) = [1, 2]
      pi(U22) = [1]
      pi(s) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          U22_A(x1) = x1 + 1
          s_A(x1) = x1 + 1
  
    precedence:
    
      mark# = U22 = s
    
    partial status:
  
      pi(mark#) = [1]
      pi(U22) = [1]
      pi(s) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1
          s_A(x1) = x1 + 1
  
    precedence:
    
      mark# = s
    
    partial status:
  
      pi(mark#) = [1]
      pi(s) = [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: U12#(mark(X1),X2) -> U12#(X1,X2)
p2: U12#(X1,active(X2)) -> U12#(X1,X2)
p3: U12#(active(X1),X2) -> U12#(X1,X2)
p4: U12#(X1,mark(X2)) -> U12#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U12#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U12# = mark = active
    
    partial status:
  
      pi(U12#) = []
      pi(mark) = [1]
      pi(active) = []

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U12#_A(x1,x2) = x1 + x2 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U12# = active = mark
    
    partial status:
  
      pi(U12#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U12#(X1,mark(X2)) -> U12#(X1,X2)
p2: U12#(active(X1),X2) -> U12#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U12#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      mark = active > U12#
    
    partial status:
  
      pi(U12#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U12#(active(X1),X2) -> U12#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U12#(active(X1),X2) -> U12#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U12#_A(x1,x2) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U12# = active
    
    partial status:
  
      pi(U12#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          isNat#_A(x1) = x1
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      isNat# = mark = active
    
    partial status:
  
      pi(isNat#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: isNat#(active(X)) -> isNat#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: isNat#(active(X)) -> isNat#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          isNat#_A(x1) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      isNat# = active
    
    partial status:
  
      pi(isNat#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U13#_A(x1) = x1
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U13# = mark = active
    
    partial status:
  
      pi(U13#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U13#(active(X)) -> U13#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U13#(active(X)) -> U13#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U13#_A(x1) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U13# = active
    
    partial status:
  
      pi(U13#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U22#_A(x1) = x1
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U22# = mark = active
    
    partial status:
  
      pi(U22#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U22#(active(X)) -> U22#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U22#(active(X)) -> U22#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U22#_A(x1) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U22# = active
    
    partial status:
  
      pi(U22#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          s#_A(x1) = x1
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      s# = mark = active
    
    partial status:
  
      pi(s#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          s#_A(x1) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      s# = active
    
    partial status:
  
      pi(s#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          plus#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      plus# = mark = active
    
    partial status:
  
      pi(plus#) = []
      pi(mark) = [1]
      pi(active) = []

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          plus#_A(x1,x2) = x1 + x2 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      plus# = active = mark
    
    partial status:
  
      pi(plus#) = [1]
      pi(active) = [1]
      pi(mark) = [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: plus#(X1,mark(X2)) -> plus#(X1,X2)
p2: plus#(active(X1),X2) -> plus#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          plus#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      mark = active > plus#
    
    partial status:
  
      pi(plus#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: plus#(active(X1),X2) -> plus#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: plus#(active(X1),X2) -> plus#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          plus#_A(x1,x2) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      plus# = active
    
    partial status:
  
      pi(plus#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U11#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U11# = mark = active
    
    partial status:
  
      pi(U11#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U11#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U11# = active = mark
    
    partial status:
  
      pi(U11#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U11#(X1,mark(X2),X3) -> U11#(X1,X2,X3)
p2: U11#(X1,X2,mark(X3)) -> U11#(X1,X2,X3)
p3: U11#(active(X1),X2,X3) -> U11#(X1,X2,X3)
p4: U11#(X1,active(X2),X3) -> U11#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U11#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U11# = mark = active
    
    partial status:
  
      pi(U11#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U11#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U11# = active = mark
    
    partial status:
  
      pi(U11#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U11#(X1,X2,mark(X3)) -> U11#(X1,X2,X3)
p2: U11#(active(X1),X2,X3) -> U11#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

p1: U11#(X1,X2,mark(X3)) -> U11#(X1,X2,X3)
p2: U11#(active(X1),X2,X3) -> U11#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U11#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U11# = mark = active
    
    partial status:
  
      pi(U11#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U11#(active(X1),X2,X3) -> U11#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U11#(active(X1),X2,X3) -> U11#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U11#_A(x1,x2,x3) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U11# = active
    
    partial status:
  
      pi(U11#) = [1]
      pi(active) = []

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          and#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      and# = mark = active
    
    partial status:
  
      pi(and#) = []
      pi(mark) = [1]
      pi(active) = []

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          and#_A(x1,x2) = x1 + x2 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      and# = active = mark
    
    partial status:
  
      pi(and#) = [1]
      pi(active) = [1]
      pi(mark) = [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: and#(X1,mark(X2)) -> and#(X1,X2)
p2: and#(active(X1),X2) -> and#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          and#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      mark = active > and#
    
    partial status:
  
      pi(and#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: and#(active(X1),X2) -> and#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: and#(active(X1),X2) -> and#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          and#_A(x1,x2) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      and# = active
    
    partial status:
  
      pi(and#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          isNatKind#_A(x1) = x1
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      isNatKind# = mark = active
    
    partial status:
  
      pi(isNatKind#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: isNatKind#(active(X)) -> isNatKind#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: isNatKind#(active(X)) -> isNatKind#(X)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          isNatKind#_A(x1) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      isNatKind# = active
    
    partial status:
  
      pi(isNatKind#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U21#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U21# = mark = active
    
    partial status:
  
      pi(U21#) = []
      pi(mark) = [1]
      pi(active) = []

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U21#_A(x1,x2) = x1 + x2 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U21# = active = mark
    
    partial status:
  
      pi(U21#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U21#(X1,mark(X2)) -> U21#(X1,X2)
p2: U21#(active(X1),X2) -> U21#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U21#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      mark = active > U21#
    
    partial status:
  
      pi(U21#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U21#(active(X1),X2) -> U21#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U21#(active(X1),X2) -> U21#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U21#_A(x1,x2) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U21# = active
    
    partial status:
  
      pi(U21#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U31#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U31# = mark = active
    
    partial status:
  
      pi(U31#) = []
      pi(mark) = [1]
      pi(active) = []

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U31#_A(x1,x2) = x1 + x2 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U31# = active = mark
    
    partial status:
  
      pi(U31#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U31#(X1,mark(X2)) -> U31#(X1,X2)
p2: U31#(active(X1),X2) -> U31#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U31#_A(x1,x2) = x1 + x2 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      mark = active > U31#
    
    partial status:
  
      pi(U31#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U31#(active(X1),X2) -> U31#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U31#(active(X1),X2) -> U31#(X1,X2)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U31#_A(x1,x2) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U31# = active
    
    partial status:
  
      pi(U31#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U41# = mark = active
    
    partial status:
  
      pi(U41#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U41# = active = mark
    
    partial status:
  
      pi(U41#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U41#(X1,mark(X2),X3) -> U41#(X1,X2,X3)
p2: U41#(X1,X2,mark(X3)) -> U41#(X1,X2,X3)
p3: U41#(active(X1),X2,X3) -> U41#(X1,X2,X3)
p4: U41#(X1,active(X2),X3) -> U41#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U41# = mark = active
    
    partial status:
  
      pi(U41#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          active_A(x1) = x1 + 1
          mark_A(x1) = x1 + 1
  
    precedence:
    
      U41# = active = mark
    
    partial status:
  
      pi(U41#) = [1]
      pi(active) = [1]
      pi(mark) = [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: U41#(X1,X2,mark(X3)) -> U41#(X1,X2,X3)
p2: U41#(active(X1),X2,X3) -> U41#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

p1: U41#(X1,X2,mark(X3)) -> U41#(X1,X2,X3)
p2: U41#(active(X1),X2,X3) -> U41#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = x1 + x2 + x3 + 2
          mark_A(x1) = x1 + 1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U41# = mark = active
    
    partial status:
  
      pi(U41#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

p1: U41#(active(X1),X2,X3) -> U41#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U41#(active(X1),X2,X3) -> U41#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V1,V2)) -> mark(U12(isNat(V1),V2))
r2: active(U12(tt(),V2)) -> mark(U13(isNat(V2)))
r3: active(U13(tt())) -> mark(tt())
r4: active(U21(tt(),V1)) -> mark(U22(isNat(V1)))
r5: active(U22(tt())) -> mark(tt())
r6: active(U31(tt(),N)) -> mark(N)
r7: active(U41(tt(),M,N)) -> mark(s(plus(N,M)))
r8: active(and(tt(),X)) -> mark(X)
r9: active(isNat(|0|())) -> mark(tt())
r10: active(isNat(plus(V1,V2))) -> mark(U11(and(isNatKind(V1),isNatKind(V2)),V1,V2))
r11: active(isNat(s(V1))) -> mark(U21(isNatKind(V1),V1))
r12: active(isNatKind(|0|())) -> mark(tt())
r13: active(isNatKind(plus(V1,V2))) -> mark(and(isNatKind(V1),isNatKind(V2)))
r14: active(isNatKind(s(V1))) -> mark(isNatKind(V1))
r15: active(plus(N,|0|())) -> mark(U31(and(isNat(N),isNatKind(N)),N))
r16: active(plus(N,s(M))) -> mark(U41(and(and(isNat(M),isNatKind(M)),and(isNat(N),isNatKind(N))),M,N))
r17: mark(U11(X1,X2,X3)) -> active(U11(mark(X1),X2,X3))
r18: mark(tt()) -> active(tt())
r19: mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
r20: mark(isNat(X)) -> active(isNat(X))
r21: mark(U13(X)) -> active(U13(mark(X)))
r22: mark(U21(X1,X2)) -> active(U21(mark(X1),X2))
r23: mark(U22(X)) -> active(U22(mark(X)))
r24: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r25: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r26: mark(s(X)) -> active(s(mark(X)))
r27: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r28: mark(and(X1,X2)) -> active(and(mark(X1),X2))
r29: mark(|0|()) -> active(|0|())
r30: mark(isNatKind(X)) -> active(isNatKind(X))
r31: U11(mark(X1),X2,X3) -> U11(X1,X2,X3)
r32: U11(X1,mark(X2),X3) -> U11(X1,X2,X3)
r33: U11(X1,X2,mark(X3)) -> U11(X1,X2,X3)
r34: U11(active(X1),X2,X3) -> U11(X1,X2,X3)
r35: U11(X1,active(X2),X3) -> U11(X1,X2,X3)
r36: U11(X1,X2,active(X3)) -> U11(X1,X2,X3)
r37: U12(mark(X1),X2) -> U12(X1,X2)
r38: U12(X1,mark(X2)) -> U12(X1,X2)
r39: U12(active(X1),X2) -> U12(X1,X2)
r40: U12(X1,active(X2)) -> U12(X1,X2)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: U13(mark(X)) -> U13(X)
r44: U13(active(X)) -> U13(X)
r45: U21(mark(X1),X2) -> U21(X1,X2)
r46: U21(X1,mark(X2)) -> U21(X1,X2)
r47: U21(active(X1),X2) -> U21(X1,X2)
r48: U21(X1,active(X2)) -> U21(X1,X2)
r49: U22(mark(X)) -> U22(X)
r50: U22(active(X)) -> U22(X)
r51: U31(mark(X1),X2) -> U31(X1,X2)
r52: U31(X1,mark(X2)) -> U31(X1,X2)
r53: U31(active(X1),X2) -> U31(X1,X2)
r54: U31(X1,active(X2)) -> U31(X1,X2)
r55: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r56: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r57: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r58: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r59: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r60: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r61: s(mark(X)) -> s(X)
r62: s(active(X)) -> s(X)
r63: plus(mark(X1),X2) -> plus(X1,X2)
r64: plus(X1,mark(X2)) -> plus(X1,X2)
r65: plus(active(X1),X2) -> plus(X1,X2)
r66: plus(X1,active(X2)) -> plus(X1,X2)
r67: and(mark(X1),X2) -> and(X1,X2)
r68: and(X1,mark(X2)) -> and(X1,X2)
r69: and(active(X1),X2) -> and(X1,X2)
r70: and(X1,active(X2)) -> and(X1,X2)
r71: isNatKind(mark(X)) -> isNatKind(X)
r72: isNatKind(active(X)) -> isNatKind(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^1
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = x1
          active_A(x1) = x1 + 1
  
    precedence:
    
      U41# = active
    
    partial status:
  
      pi(U41#) = [1]
      pi(active) = []

The next rules are strictly ordered:

  p1

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