YES

We show the termination of the TRS R:

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

-- SCC decomposition.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: active#(U11(tt(),V2)) -> U12#(isNat(V2))
p3: active#(U11(tt(),V2)) -> isNat#(V2)
p4: active#(U12(tt())) -> mark#(tt())
p5: active#(U21(tt())) -> mark#(tt())
p6: active#(U31(tt(),N)) -> mark#(N)
p7: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p8: active#(U41(tt(),M,N)) -> U42#(isNat(N),M,N)
p9: active#(U41(tt(),M,N)) -> isNat#(N)
p10: active#(U42(tt(),M,N)) -> mark#(s(plus(N,M)))
p11: active#(U42(tt(),M,N)) -> s#(plus(N,M))
p12: active#(U42(tt(),M,N)) -> plus#(N,M)
p13: active#(isNat(|0|())) -> mark#(tt())
p14: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p15: active#(isNat(plus(V1,V2))) -> U11#(isNat(V1),V2)
p16: active#(isNat(plus(V1,V2))) -> isNat#(V1)
p17: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p18: active#(isNat(s(V1))) -> U21#(isNat(V1))
p19: active#(isNat(s(V1))) -> isNat#(V1)
p20: active#(plus(N,|0|())) -> mark#(U31(isNat(N),N))
p21: active#(plus(N,|0|())) -> U31#(isNat(N),N)
p22: active#(plus(N,|0|())) -> isNat#(N)
p23: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p24: active#(plus(N,s(M))) -> U41#(isNat(M),M,N)
p25: active#(plus(N,s(M))) -> isNat#(M)
p26: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p27: mark#(U11(X1,X2)) -> U11#(mark(X1),X2)
p28: mark#(U11(X1,X2)) -> mark#(X1)
p29: mark#(tt()) -> active#(tt())
p30: mark#(U12(X)) -> active#(U12(mark(X)))
p31: mark#(U12(X)) -> U12#(mark(X))
p32: mark#(U12(X)) -> mark#(X)
p33: mark#(isNat(X)) -> active#(isNat(X))
p34: mark#(U21(X)) -> active#(U21(mark(X)))
p35: mark#(U21(X)) -> U21#(mark(X))
p36: mark#(U21(X)) -> mark#(X)
p37: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p38: mark#(U31(X1,X2)) -> U31#(mark(X1),X2)
p39: mark#(U31(X1,X2)) -> mark#(X1)
p40: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p41: mark#(U41(X1,X2,X3)) -> U41#(mark(X1),X2,X3)
p42: mark#(U41(X1,X2,X3)) -> mark#(X1)
p43: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p44: mark#(U42(X1,X2,X3)) -> U42#(mark(X1),X2,X3)
p45: mark#(U42(X1,X2,X3)) -> mark#(X1)
p46: mark#(s(X)) -> active#(s(mark(X)))
p47: mark#(s(X)) -> s#(mark(X))
p48: mark#(s(X)) -> mark#(X)
p49: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p50: mark#(plus(X1,X2)) -> plus#(mark(X1),mark(X2))
p51: mark#(plus(X1,X2)) -> mark#(X1)
p52: mark#(plus(X1,X2)) -> mark#(X2)
p53: mark#(|0|()) -> active#(|0|())
p54: U11#(mark(X1),X2) -> U11#(X1,X2)
p55: U11#(X1,mark(X2)) -> U11#(X1,X2)
p56: U11#(active(X1),X2) -> U11#(X1,X2)
p57: U11#(X1,active(X2)) -> U11#(X1,X2)
p58: U12#(mark(X)) -> U12#(X)
p59: U12#(active(X)) -> U12#(X)
p60: isNat#(mark(X)) -> isNat#(X)
p61: isNat#(active(X)) -> isNat#(X)
p62: U21#(mark(X)) -> U21#(X)
p63: U21#(active(X)) -> U21#(X)
p64: U31#(mark(X1),X2) -> U31#(X1,X2)
p65: U31#(X1,mark(X2)) -> U31#(X1,X2)
p66: U31#(active(X1),X2) -> U31#(X1,X2)
p67: U31#(X1,active(X2)) -> U31#(X1,X2)
p68: U41#(mark(X1),X2,X3) -> U41#(X1,X2,X3)
p69: U41#(X1,mark(X2),X3) -> U41#(X1,X2,X3)
p70: U41#(X1,X2,mark(X3)) -> U41#(X1,X2,X3)
p71: U41#(active(X1),X2,X3) -> U41#(X1,X2,X3)
p72: U41#(X1,active(X2),X3) -> U41#(X1,X2,X3)
p73: U41#(X1,X2,active(X3)) -> U41#(X1,X2,X3)
p74: U42#(mark(X1),X2,X3) -> U42#(X1,X2,X3)
p75: U42#(X1,mark(X2),X3) -> U42#(X1,X2,X3)
p76: U42#(X1,X2,mark(X3)) -> U42#(X1,X2,X3)
p77: U42#(active(X1),X2,X3) -> U42#(X1,X2,X3)
p78: U42#(X1,active(X2),X3) -> U42#(X1,X2,X3)
p79: U42#(X1,X2,active(X3)) -> U42#(X1,X2,X3)
p80: s#(mark(X)) -> s#(X)
p81: s#(active(X)) -> s#(X)
p82: plus#(mark(X1),X2) -> plus#(X1,X2)
p83: plus#(X1,mark(X2)) -> plus#(X1,X2)
p84: plus#(active(X1),X2) -> plus#(X1,X2)
p85: plus#(X1,active(X2)) -> plus#(X1,X2)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p6, p7, p10, p14, p17, p20, p23, p26, p28, p30, p32, p33, p34, p36, p37, p39, p40, p42, p43, p45, p46, p48, p49, p51, p52}
  {p58, p59}
  {p60, p61}
  {p74, p75, p76, p77, p78, p79}
  {p80, p81}
  {p82, p83, p84, p85}
  {p54, p55, p56, p57}
  {p62, p63}
  {p64, p65, p66, p67}
  {p68, p69, p70, p71, p72, p73}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

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

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

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

The next rules are strictly ordered:

  p5

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> mark#(X1)
p4: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p5: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U42(X1,X2,X3)) -> mark#(X1)
p8: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p9: active#(plus(N,|0|())) -> mark#(U31(isNat(N),N))
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(isNat(V1)))
p13: mark#(U31(X1,X2)) -> mark#(X1)
p14: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p15: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p16: mark#(U21(X)) -> mark#(X)
p17: mark#(U21(X)) -> active#(U21(mark(X)))
p18: active#(U42(tt(),M,N)) -> mark#(s(plus(N,M)))
p19: mark#(isNat(X)) -> active#(isNat(X))
p20: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p21: mark#(U12(X)) -> mark#(X)
p22: mark#(U11(X1,X2)) -> mark#(X1)
p23: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p24: active#(U31(tt(),N)) -> mark#(N)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

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

The next rules are strictly ordered:

  p17

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> mark#(X1)
p4: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p5: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U42(X1,X2,X3)) -> mark#(X1)
p8: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p9: active#(plus(N,|0|())) -> mark#(U31(isNat(N),N))
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(isNat(V1)))
p13: mark#(U31(X1,X2)) -> mark#(X1)
p14: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p15: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p16: mark#(U21(X)) -> mark#(X)
p17: active#(U42(tt(),M,N)) -> mark#(s(plus(N,M)))
p18: mark#(isNat(X)) -> active#(isNat(X))
p19: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p20: mark#(U12(X)) -> mark#(X)
p21: mark#(U11(X1,X2)) -> mark#(X1)
p22: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p23: active#(U31(tt(),N)) -> mark#(N)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((0,0),(1,0)) x1 + (8,24)
          U11_A(x1,x2) = ((1,0),(0,0)) x1 + ((0,0),(1,0)) x2 + (0,23)
          tt_A() = (13,17)
          mark#_A(x1) = ((0,0),(1,0)) x1 + (8,24)
          U12_A(x1) = ((1,0),(0,0)) x1 + (0,20)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (13,13)
          mark_A(x1) = x1 + (0,2)
          U31_A(x1,x2) = ((1,0),(0,0)) x1 + x2 + (9,1)
          U41_A(x1,x2,x3) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (9,33)
          U42_A(x1,x2,x3) = x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (9,30)
          U21_A(x1) = ((1,0),(0,0)) x1 + (0,20)
          s_A(x1) = ((1,0),(0,0)) x1 + (10,27)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,1)) x2 + (12,12)
          |0|_A() = (23,47)
          active_A(x1) = x1
  
    precedence:
    
      U42 > s = plus > isNat > U12 > tt > |0| > U11 > mark = active > active# = mark# = U31 = U41 > U21
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U31) = []
      pi(U41) = []
      pi(U42) = []
      pi(U21) = []
      pi(s) = []
      pi(plus) = []
      pi(|0|) = []
      pi(active) = []

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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: active#(U31(tt(),N)) -> mark#(N)
p4: mark#(U11(X1,X2)) -> mark#(X1)
p5: mark#(U12(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p8: mark#(U21(X)) -> mark#(X)
p9: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p10: active#(U42(tt(),M,N)) -> mark#(s(plus(N,M)))
p11: mark#(U31(X1,X2)) -> mark#(X1)
p12: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p13: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p14: mark#(U41(X1,X2,X3)) -> mark#(X1)
p15: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p16: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p17: mark#(U42(X1,X2,X3)) -> mark#(X1)
p18: mark#(s(X)) -> mark#(X)
p19: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p20: mark#(plus(X1,X2)) -> mark#(X1)
p21: mark#(plus(X1,X2)) -> mark#(X2)
p22: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((0,0),(1,0)) x1
          U11_A(x1,x2) = ((1,0),(0,0)) x1 + (0,40)
          tt_A() = (3,3)
          mark#_A(x1) = ((0,0),(1,0)) x1
          U12_A(x1) = ((1,0),(0,0)) x1 + (0,9)
          isNat_A(x1) = (3,48)
          plus_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (2,54)
          mark_A(x1) = ((1,0),(1,1)) x1 + (0,5)
          s_A(x1) = ((1,0),(0,0)) x1 + (6,21)
          U41_A(x1,x2,x3) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (5,48)
          U42_A(x1,x2,x3) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (5,35)
          U21_A(x1) = ((1,0),(0,0)) x1 + (0,12)
          U31_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (1,0)
          active_A(x1) = ((1,0),(1,1)) x1
          |0|_A() = (2,0)
  
    precedence:
    
      active# = U11 = tt = mark# = U12 = isNat = plus = mark = s = U41 = U42 = U21 = U31 = active = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(plus) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(U42) = []
      pi(U21) = []
      pi(U31) = []
      pi(active) = []
      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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> mark#(X1)
p4: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p5: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U42(X1,X2,X3)) -> mark#(X1)
p8: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p9: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p10: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p11: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p12: mark#(U31(X1,X2)) -> mark#(X1)
p13: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p14: active#(U42(tt(),M,N)) -> mark#(s(plus(N,M)))
p15: mark#(U21(X)) -> mark#(X)
p16: mark#(isNat(X)) -> active#(isNat(X))
p17: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p18: mark#(U12(X)) -> mark#(X)
p19: mark#(U11(X1,X2)) -> mark#(X1)
p20: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p21: active#(U31(tt(),N)) -> mark#(N)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((0,0),(1,0)) x1 + (1,4)
          U11_A(x1,x2) = ((1,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (0,5)
          tt_A() = (17,8)
          mark#_A(x1) = ((0,0),(1,0)) x1 + (1,4)
          U12_A(x1) = ((1,0),(0,0)) x1 + (0,15)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (17,20)
          mark_A(x1) = x1 + (0,6)
          U31_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(1,1)) x2 + (49,52)
          U41_A(x1,x2,x3) = ((0,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (28,33)
          U42_A(x1,x2,x3) = ((1,0),(1,1)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (11,7)
          U21_A(x1) = ((1,0),(0,0)) x1 + (0,15)
          s_A(x1) = ((1,0),(0,0)) x1 + (18,1)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + (10,57)
          active_A(x1) = x1
          |0|_A() = (57,21)
  
    precedence:
    
      U21 = plus > U12 > U41 > active# = U11 = tt = mark# = isNat = mark = U31 > active > s > U42 > |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U31) = []
      pi(U41) = []
      pi(U42) = [1]
      pi(U21) = []
      pi(s) = []
      pi(plus) = []
      pi(active) = [1]
      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(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: mark#(U11(X1,X2)) -> mark#(X1)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(isNat(X)) -> active#(isNat(X))
p6: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p7: mark#(U21(X)) -> mark#(X)
p8: mark#(U31(X1,X2)) -> active#(U31(mark(X1),X2))
p9: active#(U42(tt(),M,N)) -> mark#(s(plus(N,M)))
p10: mark#(U31(X1,X2)) -> mark#(X1)
p11: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p12: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p13: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p14: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p15: mark#(U42(X1,X2,X3)) -> mark#(X1)
p16: mark#(s(X)) -> mark#(X)
p17: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p18: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p19: mark#(plus(X1,X2)) -> mark#(X1)
p20: mark#(plus(X1,X2)) -> mark#(X2)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

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

The next rules are strictly ordered:

  p13

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + (0,2)
          U11_A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (0,9)
          tt_A() = (21,20)
          mark#_A(x1) = x1 + (0,5)
          U12_A(x1) = ((1,0),(1,1)) x1 + (0,5)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (21,3)
          mark_A(x1) = x1 + (0,2)
          U41_A(x1,x2,x3) = x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (48,22)
          U42_A(x1,x2,x3) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (48,16)
          s_A(x1) = ((1,0),(0,0)) x1 + (33,31)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (36,38)
          U21_A(x1) = ((1,0),(1,1)) x1 + (0,6)
          U31_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (1,57)
          active_A(x1) = x1
          |0|_A() = (20,2)
  
    precedence:
    
      U11 = tt = U12 > active# = U41 > mark# = U42 > plus > isNat = mark = s = U21 = U31 > |0| > active
    
    partial status:
  
      pi(active#) = [1]
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = [1]
      pi(U41) = []
      pi(U42) = []
      pi(s) = []
      pi(plus) = []
      pi(U21) = []
      pi(U31) = []
      pi(active) = []
      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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p4: mark#(U11(X1,X2)) -> mark#(X1)
p5: mark#(U12(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: mark#(U21(X)) -> mark#(X)
p8: mark#(U31(X1,X2)) -> mark#(X1)
p9: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p10: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p11: mark#(U42(X1,X2,X3)) -> active#(U42(mark(X1),X2,X3))
p12: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p13: mark#(U42(X1,X2,X3)) -> mark#(X1)
p14: mark#(s(X)) -> mark#(X)
p15: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p16: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p17: mark#(plus(X1,X2)) -> mark#(X1)
p18: mark#(plus(X1,X2)) -> mark#(X2)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((0,0),(1,0)) x1 + (6,1)
          U11_A(x1,x2) = (2,6)
          tt_A() = (7,4)
          mark#_A(x1) = (6,3)
          U12_A(x1) = (1,0)
          isNat_A(x1) = (2,5)
          plus_A(x1,x2) = (2,0)
          mark_A(x1) = (4,2)
          s_A(x1) = (5,6)
          U41_A(x1,x2,x3) = (2,0)
          U42_A(x1,x2,x3) = (1,0)
          U21_A(x1) = (1,0)
          U31_A(x1,x2) = (3,0)
          active_A(x1) = (4,2)
          |0|_A() = (5,0)
  
    precedence:
    
      U11 > U12 = s = U42 > active# = mark# = U41 > tt = plus = mark = U21 = U31 = active > isNat = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(plus) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(U42) = []
      pi(U21) = []
      pi(U31) = []
      pi(active) = []
      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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> mark#(X1)
p4: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p5: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(U42(X1,X2,X3)) -> mark#(X1)
p8: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p9: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p10: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p11: mark#(U31(X1,X2)) -> mark#(X1)
p12: mark#(U21(X)) -> mark#(X)
p13: mark#(isNat(X)) -> active#(isNat(X))
p14: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p15: mark#(U12(X)) -> mark#(X)
p16: mark#(U11(X1,X2)) -> mark#(X1)
p17: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((0,0),(1,0)) x1 + (0,5)
          U11_A(x1,x2) = ((1,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (0,19)
          tt_A() = (8,2)
          mark#_A(x1) = ((0,0),(1,0)) x1 + (0,5)
          U12_A(x1) = x1 + (0,2)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (8,20)
          mark_A(x1) = x1 + (0,1)
          U41_A(x1,x2,x3) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (10,16)
          U42_A(x1,x2,x3) = x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (10,2)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + (9,26)
          U21_A(x1) = ((1,0),(0,0)) x1 + (0,4)
          U31_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(1,0)) x2 + (1,0)
          s_A(x1) = ((1,0),(0,0)) x1 + (9,0)
          active_A(x1) = x1
          |0|_A() = (10,21)
  
    precedence:
    
      U11 > mark = U42 = U31 > U41 > active# = mark# = U12 > plus = U21 = s = active > tt > isNat > |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = [1]
      pi(isNat) = []
      pi(mark) = [1]
      pi(U41) = []
      pi(U42) = [1]
      pi(plus) = []
      pi(U21) = []
      pi(U31) = []
      pi(s) = []
      pi(active) = [1]
      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(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))
p4: mark#(U11(X1,X2)) -> mark#(X1)
p5: mark#(U12(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p8: mark#(U21(X)) -> mark#(X)
p9: mark#(U31(X1,X2)) -> mark#(X1)
p10: mark#(U41(X1,X2,X3)) -> active#(U41(mark(X1),X2,X3))
p11: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p12: mark#(U42(X1,X2,X3)) -> mark#(X1)
p13: mark#(s(X)) -> mark#(X)
p14: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p15: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p16: mark#(plus(X1,X2)) -> mark#(X2)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((1,0),(1,1)) x1
          U11_A(x1,x2) = x1 + ((0,0),(1,0)) x2 + (0,1)
          tt_A() = (10,20)
          mark#_A(x1) = ((1,0),(1,1)) x1 + (0,2)
          U12_A(x1) = x1 + (0,1)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (10,6)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (4,0)
          mark_A(x1) = x1
          s_A(x1) = ((1,0),(0,0)) x1 + (9,0)
          U41_A(x1,x2,x3) = ((1,0),(1,0)) x2 + ((1,0),(1,0)) x3 + (13,6)
          U42_A(x1,x2,x3) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (3,3)
          U21_A(x1) = x1 + (0,3)
          U31_A(x1,x2) = x1 + x2 + (1,0)
          active_A(x1) = x1
          |0|_A() = (15,1)
  
    precedence:
    
      U12 = mark = U42 = U21 > isNat > s > plus > active# = tt = mark# = U41 = active > U11 = |0| > U31
    
    partial status:
  
      pi(active#) = []
      pi(U11) = [1]
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = [1]
      pi(isNat) = []
      pi(plus) = []
      pi(mark) = [1]
      pi(s) = []
      pi(U41) = []
      pi(U42) = []
      pi(U21) = [1]
      pi(U31) = []
      pi(active) = [1]
      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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p4: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(U42(X1,X2,X3)) -> mark#(X1)
p7: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p8: mark#(U31(X1,X2)) -> mark#(X1)
p9: mark#(U21(X)) -> mark#(X)
p10: mark#(isNat(X)) -> active#(isNat(X))
p11: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p12: mark#(U12(X)) -> mark#(X)
p13: mark#(U11(X1,X2)) -> mark#(X1)
p14: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p15: active#(U41(tt(),M,N)) -> mark#(U42(isNat(N),M,N))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((1,0),(0,0)) x1 + (0,3)
          U11_A(x1,x2) = (1,1)
          tt_A() = (1,5)
          mark#_A(x1) = (1,3)
          U12_A(x1) = (5,0)
          isNat_A(x1) = (1,6)
          mark_A(x1) = (4,7)
          U41_A(x1,x2,x3) = (3,2)
          U42_A(x1,x2,x3) = (2,1)
          plus_A(x1,x2) = (1,4)
          U21_A(x1) = (3,0)
          U31_A(x1,x2) = (2,0)
          s_A(x1) = (0,8)
          active_A(x1) = (4,7)
          |0|_A() = (5,8)
  
    precedence:
    
      active# = U11 = mark# > tt = U12 = isNat = mark = U41 = U42 = U21 = U31 = s = active = |0| > plus
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(U41) = []
      pi(U42) = []
      pi(plus) = []
      pi(U21) = []
      pi(U31) = []
      pi(s) = []
      pi(active) = []
      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(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: mark#(U11(X1,X2)) -> mark#(X1)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(isNat(X)) -> active#(isNat(X))
p6: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p7: mark#(U21(X)) -> mark#(X)
p8: mark#(U31(X1,X2)) -> mark#(X1)
p9: mark#(U42(X1,X2,X3)) -> mark#(X1)
p10: mark#(s(X)) -> mark#(X)
p11: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p12: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p13: mark#(plus(X1,X2)) -> mark#(X2)
p14: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p4: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(U42(X1,X2,X3)) -> mark#(X1)
p7: mark#(U31(X1,X2)) -> mark#(X1)
p8: mark#(U21(X)) -> mark#(X)
p9: mark#(isNat(X)) -> active#(isNat(X))
p10: active#(isNat(s(V1))) -> mark#(U21(isNat(V1)))
p11: mark#(U12(X)) -> mark#(X)
p12: mark#(U11(X1,X2)) -> mark#(X1)
p13: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p14: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2) = x1 + ((0,0),(1,0)) x2 + (0,3)
          tt_A() = (0,5)
          mark#_A(x1) = ((1,0),(1,1)) x1 + (0,2)
          U12_A(x1) = x1 + (0,3)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (0,1)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (6,16)
          mark_A(x1) = x1
          s_A(x1) = ((1,0),(0,0)) x1 + (6,4)
          U41_A(x1,x2,x3) = ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (12,7)
          U42_A(x1,x2,x3) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (12,6)
          U31_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (10,3)
          U21_A(x1) = x1 + (0,3)
          active_A(x1) = x1
          |0|_A() = (5,6)
  
    precedence:
    
      active# = U11 = tt = mark# = U12 = isNat = plus = mark = s = U41 = U42 = U31 = U21 = active = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(plus) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(U42) = []
      pi(U31) = []
      pi(U21) = []
      pi(active) = []
      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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> mark#(X2)
p3: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p4: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(U42(X1,X2,X3)) -> mark#(X1)
p7: mark#(U31(X1,X2)) -> mark#(X1)
p8: mark#(U21(X)) -> mark#(X)
p9: mark#(isNat(X)) -> active#(isNat(X))
p10: mark#(U12(X)) -> mark#(X)
p11: mark#(U11(X1,X2)) -> mark#(X1)
p12: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p13: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p4: mark#(U11(X1,X2)) -> mark#(X1)
p5: mark#(U12(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p8: mark#(U21(X)) -> mark#(X)
p9: mark#(U31(X1,X2)) -> mark#(X1)
p10: mark#(U42(X1,X2,X3)) -> mark#(X1)
p11: mark#(s(X)) -> mark#(X)
p12: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p13: mark#(plus(X1,X2)) -> mark#(X2)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1 + (0,1)
          U11_A(x1,x2) = x1 + ((0,0),(1,0)) x2
          tt_A() = (18,18)
          mark#_A(x1) = x1 + (0,8)
          U12_A(x1) = x1 + (0,9)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (18,0)
          mark_A(x1) = x1 + (0,2)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (19,0)
          s_A(x1) = ((1,0),(0,0)) x1 + (19,4)
          U41_A(x1,x2,x3) = x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (20,3)
          U21_A(x1) = x1 + (0,3)
          U31_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(0,0)) x2 + (4,3)
          U42_A(x1,x2,x3) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (20,7)
          active_A(x1) = x1
          |0|_A() = (21,24)
  
    precedence:
    
      U12 = U41 > U21 = U42 > plus > active# = U11 = tt = mark# = isNat = mark = s = U31 = active = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(plus) = []
      pi(s) = []
      pi(U41) = []
      pi(U21) = []
      pi(U31) = []
      pi(U42) = []
      pi(active) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p13

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))
p3: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p4: mark#(U11(X1,X2)) -> mark#(X1)
p5: mark#(U12(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p8: mark#(U21(X)) -> mark#(X)
p9: mark#(U31(X1,X2)) -> mark#(X1)
p10: mark#(U42(X1,X2,X3)) -> mark#(X1)
p11: mark#(s(X)) -> mark#(X)
p12: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p3: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p4: mark#(s(X)) -> mark#(X)
p5: mark#(U42(X1,X2,X3)) -> mark#(X1)
p6: mark#(U31(X1,X2)) -> mark#(X1)
p7: mark#(U21(X)) -> mark#(X)
p8: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p10: mark#(U12(X)) -> mark#(X)
p11: mark#(U11(X1,X2)) -> mark#(X1)
p12: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((1,0),(0,0)) x1 + (7,0)
          U11_A(x1,x2) = ((1,0),(0,0)) x1
          tt_A() = (0,0)
          mark#_A(x1) = ((1,0),(0,0)) x1 + (7,0)
          U12_A(x1) = ((1,0),(0,0)) x1
          isNat_A(x1) = ((0,0),(1,0)) x1 + (0,2)
          plus_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(1,0)) x2 + (2,1)
          mark_A(x1) = x1 + (0,4)
          s_A(x1) = ((1,0),(0,0)) x1 + (4,0)
          U41_A(x1,x2,x3) = ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (6,0)
          U42_A(x1,x2,x3) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (6,0)
          U31_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (8,5)
          U21_A(x1) = ((1,0),(0,0)) x1
          active_A(x1) = ((1,0),(0,0)) x1 + (0,4)
          |0|_A() = (7,10)
  
    precedence:
    
      U41 > active# = U11 = mark# = isNat = U31 > tt = U12 = plus = mark = s = U42 = U21 = active = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(plus) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(U42) = []
      pi(U31) = []
      pi(U21) = []
      pi(active) = []
      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: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p3: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p4: mark#(s(X)) -> mark#(X)
p5: mark#(U42(X1,X2,X3)) -> mark#(X1)
p6: mark#(U21(X)) -> mark#(X)
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p9: mark#(U12(X)) -> mark#(X)
p10: mark#(U11(X1,X2)) -> mark#(X1)
p11: mark#(U11(X1,X2)) -> active#(U11(mark(X1),X2))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = x1
          U11_A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (0,11)
          tt_A() = (2,20)
          mark#_A(x1) = ((1,0),(1,1)) x1 + (0,1)
          U12_A(x1) = ((1,0),(1,1)) x1 + (0,2)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (2,25)
          mark_A(x1) = x1
          plus_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (17,21)
          s_A(x1) = ((1,0),(0,0)) x1 + (5,30)
          U41_A(x1,x2,x3) = ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (22,32)
          U21_A(x1) = ((1,0),(1,1)) x1 + (0,2)
          U42_A(x1,x2,x3) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (20,29)
          active_A(x1) = x1
          U31_A(x1,x2) = x2 + (0,1)
          |0|_A() = (1,2)
  
    precedence:
    
      mark > tt = U12 = U41 > s > U21 > active# = U11 = mark# = isNat = plus > U42 > active = U31 = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = [1]
      pi(U12) = []
      pi(isNat) = []
      pi(mark) = []
      pi(plus) = []
      pi(s) = []
      pi(U41) = []
      pi(U21) = []
      pi(U42) = []
      pi(active) = [1]
      pi(U31) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p3: mark#(U11(X1,X2)) -> mark#(X1)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(isNat(X)) -> active#(isNat(X))
p6: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p7: mark#(U21(X)) -> mark#(X)
p8: mark#(U42(X1,X2,X3)) -> mark#(X1)
p9: mark#(s(X)) -> mark#(X)
p10: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(U11(tt(),V2)) -> mark#(U12(isNat(V2)))
p2: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p3: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p4: mark#(s(X)) -> mark#(X)
p5: mark#(U42(X1,X2,X3)) -> mark#(X1)
p6: mark#(U21(X)) -> mark#(X)
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p9: mark#(U12(X)) -> mark#(X)
p10: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          active#_A(x1) = ((0,0),(1,0)) x1 + (3,1)
          U11_A(x1,x2) = (9,12)
          tt_A() = (9,14)
          mark#_A(x1) = (3,3)
          U12_A(x1) = (8,11)
          isNat_A(x1) = (2,16)
          plus_A(x1,x2) = (2,13)
          mark_A(x1) = (7,15)
          s_A(x1) = (5,0)
          U41_A(x1,x2,x3) = (1,1)
          U42_A(x1,x2,x3) = (6,16)
          U21_A(x1) = (4,0)
          active_A(x1) = (7,15)
          U31_A(x1,x2) = (8,16)
          |0|_A() = (1,13)
  
    precedence:
    
      U12 = plus > U31 > U11 = isNat = mark = s = U41 = active > U42 > active# = tt = mark# > U21 = |0|
    
    partial status:
  
      pi(active#) = []
      pi(U11) = []
      pi(tt) = []
      pi(mark#) = []
      pi(U12) = []
      pi(isNat) = []
      pi(plus) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(U42) = []
      pi(U21) = []
      pi(active) = []
      pi(U31) = []
      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#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p3: mark#(s(X)) -> mark#(X)
p4: mark#(U42(X1,X2,X3)) -> mark#(X1)
p5: mark#(U21(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p8: mark#(U12(X)) -> mark#(X)
p9: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(isNat(plus(V1,V2))) -> mark#(U11(isNat(V1),V2))
p3: mark#(U11(X1,X2)) -> mark#(X1)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(isNat(X)) -> active#(isNat(X))
p6: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p7: mark#(U21(X)) -> mark#(X)
p8: mark#(U42(X1,X2,X3)) -> mark#(X1)
p9: mark#(s(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + (0,2)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,1)) x2 + (13,11)
          active#_A(x1) = x1
          mark_A(x1) = x1
          isNat_A(x1) = ((0,0),(1,0)) x1 + (1,1)
          U11_A(x1,x2) = x1 + ((0,0),(1,0)) x2 + (0,10)
          U12_A(x1) = x1 + (0,5)
          s_A(x1) = ((1,0),(0,0)) x1 + (7,6)
          U41_A(x1,x2,x3) = ((0,0),(1,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (20,4)
          U21_A(x1) = ((1,0),(1,1)) x1 + (0,5)
          U42_A(x1,x2,x3) = ((1,0),(1,1)) x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (19,2)
          active_A(x1) = x1
          tt_A() = (1,7)
          U31_A(x1,x2) = ((1,0),(1,0)) x2 + (6,19)
          |0|_A() = (7,2)
  
    precedence:
    
      mark = U41 > U42 > mark# = plus = active# = isNat = U11 = |0| > active > U21 = U31 > s > tt > U12
    
    partial status:
  
      pi(mark#) = [1]
      pi(plus) = []
      pi(active#) = []
      pi(mark) = [1]
      pi(isNat) = []
      pi(U11) = []
      pi(U12) = [1]
      pi(s) = []
      pi(U41) = []
      pi(U21) = []
      pi(U42) = []
      pi(active) = [1]
      pi(tt) = []
      pi(U31) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: mark#(U11(X1,X2)) -> mark#(X1)
p3: mark#(U12(X)) -> mark#(X)
p4: mark#(isNat(X)) -> active#(isNat(X))
p5: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p6: mark#(U21(X)) -> mark#(X)
p7: mark#(U42(X1,X2,X3)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p3: mark#(s(X)) -> mark#(X)
p4: mark#(U42(X1,X2,X3)) -> mark#(X1)
p5: mark#(U21(X)) -> mark#(X)
p6: mark#(isNat(X)) -> active#(isNat(X))
p7: mark#(U12(X)) -> mark#(X)
p8: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = (7,7)
          plus_A(x1,x2) = (6,12)
          active#_A(x1) = ((0,0),(1,0)) x1 + (7,1)
          mark_A(x1) = (4,13)
          s_A(x1) = (3,1)
          U41_A(x1,x2,x3) = (0,0)
          isNat_A(x1) = (2,9)
          U42_A(x1,x2,x3) = (2,11)
          U21_A(x1) = (1,11)
          U12_A(x1) = (3,9)
          U11_A(x1,x2) = (5,8)
          active_A(x1) = (4,13)
          tt_A() = (7,10)
          U31_A(x1,x2) = (7,14)
          |0|_A() = (8,15)
  
    precedence:
    
      U42 = U21 > mark# = plus = active# = mark = s = U41 = isNat = U12 = active > U11 = U31 = |0| > tt
    
    partial status:
  
      pi(mark#) = []
      pi(plus) = []
      pi(active#) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(isNat) = []
      pi(U42) = []
      pi(U21) = []
      pi(U12) = []
      pi(U11) = []
      pi(active) = []
      pi(tt) = []
      pi(U31) = []
      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#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p3: mark#(s(X)) -> mark#(X)
p4: mark#(U42(X1,X2,X3)) -> mark#(X1)
p5: mark#(U21(X)) -> mark#(X)
p6: mark#(U12(X)) -> mark#(X)
p7: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p3: mark#(U11(X1,X2)) -> mark#(X1)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(U21(X)) -> mark#(X)
p6: mark#(U42(X1,X2,X3)) -> mark#(X1)
p7: mark#(s(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = ((1,0),(0,0)) x1 + (1,2)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,1)) x2 + (7,13)
          active#_A(x1) = ((1,0),(0,0)) x1 + (1,2)
          mark_A(x1) = x1 + (0,3)
          s_A(x1) = ((1,0),(0,0)) x1 + (14,1)
          U41_A(x1,x2,x3) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + ((1,0),(1,0)) x3 + (15,10)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (6,4)
          U11_A(x1,x2) = x1 + ((0,0),(1,0)) x2 + (0,3)
          U12_A(x1) = x1 + (0,5)
          U21_A(x1) = ((1,0),(0,0)) x1 + (0,14)
          U42_A(x1,x2,x3) = x1 + ((1,0),(0,0)) x2 + ((1,0),(0,0)) x3 + (15,2)
          active_A(x1) = x1
          tt_A() = (6,10)
          U31_A(x1,x2) = ((1,0),(1,0)) x2 + (1,22)
          |0|_A() = (10,1)
  
    precedence:
    
      isNat = tt > U11 > mark# = active# = s > plus = U41 > mark = active = |0| > U12 = U42 = U31 > U21
    
    partial status:
  
      pi(mark#) = []
      pi(plus) = []
      pi(active#) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(isNat) = []
      pi(U11) = []
      pi(U12) = []
      pi(U21) = []
      pi(U42) = []
      pi(active) = []
      pi(tt) = []
      pi(U31) = []
      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#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p3: mark#(U11(X1,X2)) -> mark#(X1)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(U21(X)) -> mark#(X)
p6: mark#(U42(X1,X2,X3)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: active#(plus(N,s(M))) -> mark#(U41(isNat(M),M,N))
p3: mark#(U42(X1,X2,X3)) -> mark#(X1)
p4: mark#(U21(X)) -> mark#(X)
p5: mark#(U12(X)) -> mark#(X)
p6: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = ((1,0),(0,0)) x1 + (0,47)
          plus_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (53,17)
          active#_A(x1) = (49,16)
          mark_A(x1) = x1 + (0,21)
          s_A(x1) = (46,1)
          U41_A(x1,x2,x3) = (48,15)
          isNat_A(x1) = ((0,0),(1,0)) x1 + (1,0)
          U42_A(x1,x2,x3) = ((1,0),(1,0)) x1 + (46,7)
          U21_A(x1) = ((1,0),(1,0)) x1 + (0,23)
          U12_A(x1) = ((1,0),(0,0)) x1 + (0,24)
          U11_A(x1,x2) = ((1,0),(0,0)) x1 + (0,46)
          active_A(x1) = x1 + (0,15)
          tt_A() = (1,17)
          U31_A(x1,x2) = x2 + (25,21)
          |0|_A() = (24,21)
  
    precedence:
    
      U12 = tt > mark = U41 = active = U31 > U42 = U21 > mark# = plus = active# = isNat > U11 = |0| > s
    
    partial status:
  
      pi(mark#) = []
      pi(plus) = []
      pi(active#) = []
      pi(mark) = []
      pi(s) = []
      pi(U41) = []
      pi(isNat) = []
      pi(U42) = []
      pi(U21) = []
      pi(U12) = []
      pi(U11) = []
      pi(active) = []
      pi(tt) = []
      pi(U31) = []
      pi(|0|) = []

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(plus(X1,X2)) -> active#(plus(mark(X1),mark(X2)))
p2: mark#(U42(X1,X2,X3)) -> mark#(X1)
p3: mark#(U21(X)) -> mark#(X)
p4: mark#(U12(X)) -> mark#(X)
p5: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p2, p3, p4, p5}


-- Reduction pair.

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

p1: mark#(U42(X1,X2,X3)) -> mark#(X1)
p2: mark#(U11(X1,X2)) -> mark#(X1)
p3: mark#(U12(X)) -> mark#(X)
p4: mark#(U21(X)) -> mark#(X)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = ((1,0),(0,0)) x1
          U42_A(x1,x2,x3) = ((1,0),(0,0)) x1 + x2 + (1,1)
          U11_A(x1,x2) = ((1,0),(0,0)) x1 + x2 + (1,1)
          U12_A(x1) = ((1,0),(0,0)) x1 + (1,1)
          U21_A(x1) = ((1,0),(0,0)) x1 + (1,1)
  
    precedence:
    
      U12 > U21 > U42 > mark# = U11
    
    partial status:
  
      pi(mark#) = []
      pi(U42) = []
      pi(U11) = []
      pi(U12) = []
      pi(U21) = []

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: mark#(U42(X1,X2,X3)) -> mark#(X1)
p2: mark#(U21(X)) -> mark#(X)
p3: mark#(U11(X1,X2)) -> mark#(X1)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = ((1,0),(0,0)) x1
          U42_A(x1,x2,x3) = ((1,0),(0,0)) x1 + (1,1)
          U21_A(x1) = ((1,0),(0,0)) x1 + (1,1)
          U11_A(x1,x2) = ((1,0),(0,0)) x1 + (1,1)
  
    precedence:
    
      mark# = U42 = U21 = U11
    
    partial status:
  
      pi(mark#) = []
      pi(U42) = []
      pi(U21) = []
      pi(U11) = []

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          mark#_A(x1) = x1 + (1,2)
          U42_A(x1,x2,x3) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + x3 + (2,1)
          U11_A(x1,x2) = x1 + x2 + (2,3)
  
    precedence:
    
      mark# = U42 = U11
    
    partial status:
  
      pi(mark#) = [1]
      pi(U42) = [3]
      pi(U11) = [1, 2]

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          U12#_A(x1) = ((1,0),(0,0)) x1 + (1,1)
          mark_A(x1) = x1 + (2,2)
          active_A(x1) = ((1,0),(0,0)) x1 + (2,2)
  
    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#(active(X)) -> U12#(X)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: U42#(X1,X2,mark(X3)) -> U42#(X1,X2,X3)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          U42#_A(x1,x2,x3) = x3
          mark_A(x1) = x1
  
    precedence:
    
      mark > U42#
    
    partial status:
  
      pi(U42#) = [3]
      pi(mark) = [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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          s#_A(x1) = ((1,0),(1,0)) x1 + (2,2)
          active_A(x1) = ((1,0),(0,0)) x1 + (1,1)
  
    precedence:
    
      s# = active
    
    partial status:
  
      pi(s#) = []
      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: 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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: plus#(mark(X1),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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: plus#(mark(X1),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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          U21#_A(x1) = ((1,0),(0,0)) x1 + (1,1)
          mark_A(x1) = x1 + (2,2)
          active_A(x1) = ((1,0),(0,0)) x1 + (2,2)
  
    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#(active(X)) -> U21#(X)

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          U21#_A(x1) = ((1,0),(1,0)) x1 + (2,2)
          active_A(x1) = ((1,0),(0,0)) x1 + (1,1)
  
    precedence:
    
      U21# = active
    
    partial status:
  
      pi(U21#) = []
      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: 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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: U31#(mark(X1),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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: U31#(mark(X1),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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          U31#_A(x1,x2) = x1
          mark_A(x1) = x1 + (1,1)
  
    precedence:
    
      U31# = mark
    
    partial status:
  
      pi(U31#) = []
      pi(mark) = [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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          U41#_A(x1,x2,x3) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + ((0,0),(1,0)) x3 + (1,2)
          mark_A(x1) = ((1,0),(0,0)) x1 + (2,1)
          active_A(x1) = ((1,0),(0,0)) x1 + (2,1)
  
    precedence:
    
      U41# = mark = active
    
    partial status:
  
      pi(U41#) = []
      pi(mark) = []
      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: 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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5}


-- Reduction pair.

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

p1: 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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: U41#(X1,X2,active(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(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: active(U11(tt(),V2)) -> mark(U12(isNat(V2)))
r2: active(U12(tt())) -> mark(tt())
r3: active(U21(tt())) -> mark(tt())
r4: active(U31(tt(),N)) -> mark(N)
r5: active(U41(tt(),M,N)) -> mark(U42(isNat(N),M,N))
r6: active(U42(tt(),M,N)) -> mark(s(plus(N,M)))
r7: active(isNat(|0|())) -> mark(tt())
r8: active(isNat(plus(V1,V2))) -> mark(U11(isNat(V1),V2))
r9: active(isNat(s(V1))) -> mark(U21(isNat(V1)))
r10: active(plus(N,|0|())) -> mark(U31(isNat(N),N))
r11: active(plus(N,s(M))) -> mark(U41(isNat(M),M,N))
r12: mark(U11(X1,X2)) -> active(U11(mark(X1),X2))
r13: mark(tt()) -> active(tt())
r14: mark(U12(X)) -> active(U12(mark(X)))
r15: mark(isNat(X)) -> active(isNat(X))
r16: mark(U21(X)) -> active(U21(mark(X)))
r17: mark(U31(X1,X2)) -> active(U31(mark(X1),X2))
r18: mark(U41(X1,X2,X3)) -> active(U41(mark(X1),X2,X3))
r19: mark(U42(X1,X2,X3)) -> active(U42(mark(X1),X2,X3))
r20: mark(s(X)) -> active(s(mark(X)))
r21: mark(plus(X1,X2)) -> active(plus(mark(X1),mark(X2)))
r22: mark(|0|()) -> active(|0|())
r23: U11(mark(X1),X2) -> U11(X1,X2)
r24: U11(X1,mark(X2)) -> U11(X1,X2)
r25: U11(active(X1),X2) -> U11(X1,X2)
r26: U11(X1,active(X2)) -> U11(X1,X2)
r27: U12(mark(X)) -> U12(X)
r28: U12(active(X)) -> U12(X)
r29: isNat(mark(X)) -> isNat(X)
r30: isNat(active(X)) -> isNat(X)
r31: U21(mark(X)) -> U21(X)
r32: U21(active(X)) -> U21(X)
r33: U31(mark(X1),X2) -> U31(X1,X2)
r34: U31(X1,mark(X2)) -> U31(X1,X2)
r35: U31(active(X1),X2) -> U31(X1,X2)
r36: U31(X1,active(X2)) -> U31(X1,X2)
r37: U41(mark(X1),X2,X3) -> U41(X1,X2,X3)
r38: U41(X1,mark(X2),X3) -> U41(X1,X2,X3)
r39: U41(X1,X2,mark(X3)) -> U41(X1,X2,X3)
r40: U41(active(X1),X2,X3) -> U41(X1,X2,X3)
r41: U41(X1,active(X2),X3) -> U41(X1,X2,X3)
r42: U41(X1,X2,active(X3)) -> U41(X1,X2,X3)
r43: U42(mark(X1),X2,X3) -> U42(X1,X2,X3)
r44: U42(X1,mark(X2),X3) -> U42(X1,X2,X3)
r45: U42(X1,X2,mark(X3)) -> U42(X1,X2,X3)
r46: U42(active(X1),X2,X3) -> U42(X1,X2,X3)
r47: U42(X1,active(X2),X3) -> U42(X1,X2,X3)
r48: U42(X1,X2,active(X3)) -> U42(X1,X2,X3)
r49: s(mark(X)) -> s(X)
r50: s(active(X)) -> s(X)
r51: plus(mark(X1),X2) -> plus(X1,X2)
r52: plus(X1,mark(X2)) -> plus(X1,X2)
r53: plus(active(X1),X2) -> plus(X1,X2)
r54: plus(X1,active(X2)) -> plus(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

The next rules are strictly ordered:

  p1

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