YES

We show the termination of the TRS R:

  __(__(X,Y),Z) -> __(X,__(Y,Z))
  __(X,nil()) -> X
  __(nil(),X) -> X
  U11(tt()) -> tt()
  U21(tt(),V2) -> U22(isList(activate(V2)))
  U22(tt()) -> tt()
  U31(tt()) -> tt()
  U41(tt(),V2) -> U42(isNeList(activate(V2)))
  U42(tt()) -> tt()
  U51(tt(),V2) -> U52(isList(activate(V2)))
  U52(tt()) -> tt()
  U61(tt()) -> tt()
  U71(tt(),P) -> U72(isPal(activate(P)))
  U72(tt()) -> tt()
  U81(tt()) -> tt()
  isList(V) -> U11(isNeList(activate(V)))
  isList(n__nil()) -> tt()
  isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
  isNeList(V) -> U31(isQid(activate(V)))
  isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
  isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
  isNePal(V) -> U61(isQid(activate(V)))
  isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
  isPal(V) -> U81(isNePal(activate(V)))
  isPal(n__nil()) -> tt()
  isQid(n__a()) -> tt()
  isQid(n__e()) -> tt()
  isQid(n__i()) -> tt()
  isQid(n__o()) -> tt()
  isQid(n__u()) -> tt()
  nil() -> n__nil()
  __(X1,X2) -> n____(X1,X2)
  a() -> n__a()
  e() -> n__e()
  i() -> n__i()
  o() -> n__o()
  u() -> n__u()
  activate(n__nil()) -> nil()
  activate(n____(X1,X2)) -> __(X1,X2)
  activate(n__a()) -> a()
  activate(n__e()) -> e()
  activate(n__i()) -> i()
  activate(n__o()) -> o()
  activate(n__u()) -> u()
  activate(X) -> X

-- SCC decomposition.

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

p1: __#(__(X,Y),Z) -> __#(X,__(Y,Z))
p2: __#(__(X,Y),Z) -> __#(Y,Z)
p3: U21#(tt(),V2) -> U22#(isList(activate(V2)))
p4: U21#(tt(),V2) -> isList#(activate(V2))
p5: U21#(tt(),V2) -> activate#(V2)
p6: U41#(tt(),V2) -> U42#(isNeList(activate(V2)))
p7: U41#(tt(),V2) -> isNeList#(activate(V2))
p8: U41#(tt(),V2) -> activate#(V2)
p9: U51#(tt(),V2) -> U52#(isList(activate(V2)))
p10: U51#(tt(),V2) -> isList#(activate(V2))
p11: U51#(tt(),V2) -> activate#(V2)
p12: U71#(tt(),P) -> U72#(isPal(activate(P)))
p13: U71#(tt(),P) -> isPal#(activate(P))
p14: U71#(tt(),P) -> activate#(P)
p15: isList#(V) -> U11#(isNeList(activate(V)))
p16: isList#(V) -> isNeList#(activate(V))
p17: isList#(V) -> activate#(V)
p18: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p19: isList#(n____(V1,V2)) -> isList#(activate(V1))
p20: isList#(n____(V1,V2)) -> activate#(V1)
p21: isList#(n____(V1,V2)) -> activate#(V2)
p22: isNeList#(V) -> U31#(isQid(activate(V)))
p23: isNeList#(V) -> isQid#(activate(V))
p24: isNeList#(V) -> activate#(V)
p25: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))
p26: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p27: isNeList#(n____(V1,V2)) -> activate#(V1)
p28: isNeList#(n____(V1,V2)) -> activate#(V2)
p29: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p30: isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
p31: isNeList#(n____(V1,V2)) -> activate#(V1)
p32: isNeList#(n____(V1,V2)) -> activate#(V2)
p33: isNePal#(V) -> U61#(isQid(activate(V)))
p34: isNePal#(V) -> isQid#(activate(V))
p35: isNePal#(V) -> activate#(V)
p36: isNePal#(n____(I,__(P,I))) -> U71#(isQid(activate(I)),activate(P))
p37: isNePal#(n____(I,__(P,I))) -> isQid#(activate(I))
p38: isNePal#(n____(I,__(P,I))) -> activate#(I)
p39: isNePal#(n____(I,__(P,I))) -> activate#(P)
p40: isPal#(V) -> U81#(isNePal(activate(V)))
p41: isPal#(V) -> isNePal#(activate(V))
p42: isPal#(V) -> activate#(V)
p43: activate#(n__nil()) -> nil#()
p44: activate#(n____(X1,X2)) -> __#(X1,X2)
p45: activate#(n__a()) -> a#()
p46: activate#(n__e()) -> e#()
p47: activate#(n__i()) -> i#()
p48: activate#(n__o()) -> o#()
p49: activate#(n__u()) -> u#()

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p13, p36, p41}
  {p4, p7, p10, p16, p18, p19, p25, p26, p29, p30}
  {p1, p2}


-- Reduction pair.

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

p1: isPal#(V) -> isNePal#(activate(V))
p2: isNePal#(n____(I,__(P,I))) -> U71#(isQid(activate(I)),activate(P))
p3: U71#(tt(),P) -> isPal#(activate(P))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isPal#_A(x1) = ((0,0),(1,0)) x1 + (0,10)
          isNePal#_A(x1) = ((0,0),(1,0)) x1 + (0,7)
          activate_A(x1) = x1 + (2,14)
          n_____A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (0,7)
          ___A(x1,x2) = ((1,0),(1,1)) x1 + x2 + (0,22)
          U71#_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (0,1)
          isQid_A(x1) = ((1,0),(0,0)) x1 + (1,8)
          tt_A() = (12,2)
          nil_A() = (2,2)
          n__nil_A() = (1,1)
          a_A() = (14,18)
          n__a_A() = (13,3)
          e_A() = (14,2)
          n__e_A() = (13,1)
          i_A() = (14,0)
          n__i_A() = (13,3)
          o_A() = (14,0)
          n__o_A() = (13,3)
          u_A() = (14,2)
          n__u_A() = (13,1)
  
    precedence:
    
      isQid > __ = tt = n__e > e > u > n__u > isPal# = isNePal# = U71# > activate > nil = n__nil > o = n__o > i = n__i > n____ = a = n__a
    
    partial status:
  
      pi(isPal#) = []
      pi(isNePal#) = []
      pi(activate) = [1]
      pi(n____) = []
      pi(__) = [1, 2]
      pi(U71#) = []
      pi(isQid) = []
      pi(tt) = []
      pi(nil) = []
      pi(n__nil) = []
      pi(a) = []
      pi(n__a) = []
      pi(e) = []
      pi(n__e) = []
      pi(i) = []
      pi(n__i) = []
      pi(o) = []
      pi(n__o) = []
      pi(u) = []
      pi(n__u) = []

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: isPal#(V) -> isNePal#(activate(V))
p2: isNePal#(n____(I,__(P,I))) -> U71#(isQid(activate(I)),activate(P))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  (no SCCs)

-- Reduction pair.

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

p1: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(n____(V1,V2)) -> isList#(activate(V1))
p4: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p5: U21#(tt(),V2) -> isList#(activate(V2))
p6: isList#(V) -> isNeList#(activate(V))
p7: isNeList#(n____(V1,V2)) -> isNeList#(activate(V1))
p8: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p9: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))
p10: U41#(tt(),V2) -> isNeList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r16, r17, r18, r19, r20, r21, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isNeList#_A(x1) = x1 + (26,19)
          n_____A(x1,x2) = ((1,0),(1,0)) x1 + x2 + (25,23)
          U51#_A(x1,x2) = ((1,0),(1,1)) x1 + x2 + (23,5)
          isNeList_A(x1) = ((0,0),(1,0)) x1 + (27,2)
          activate_A(x1) = x1 + (0,7)
          tt_A() = (5,25)
          isList#_A(x1) = x1 + (27,27)
          U21#_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (23,0)
          isList_A(x1) = ((0,0),(1,0)) x1 + (18,3)
          U41#_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (33,42)
          U22_A(x1) = ((1,0),(0,0)) x1 + (0,26)
          U42_A(x1) = (5,26)
          U52_A(x1) = (6,1)
          ___A(x1,x2) = ((1,0),(1,0)) x1 + x2 + (25,24)
          nil_A() = (23,2)
          U11_A(x1) = ((0,0),(1,0)) x1 + (17,21)
          U21_A(x1,x2) = (18,27)
          U31_A(x1) = (6,1)
          U41_A(x1,x2) = ((1,0),(1,1)) x1 + (8,1)
          U51_A(x1,x2) = ((0,0),(1,0)) x1 + (26,1)
          isQid_A(x1) = ((1,0),(0,0)) x1 + (1,26)
          n__a_A() = (6,1)
          n__e_A() = (6,26)
          n__i_A() = (6,26)
          n__o_A() = (6,1)
          n__u_A() = (6,1)
          n__nil_A() = (23,1)
          a_A() = (6,2)
          e_A() = (6,32)
          i_A() = (6,27)
          o_A() = (6,2)
          u_A() = (6,7)
  
    precedence:
    
      activate = isList = __ = U21 = n__a = n__i = a > i > U11 = n__e = e > isNeList# = U51# = isList# = U21# = U41# > n____ > n__o = o > U52 = nil = U31 = isQid > isNeList = U41 > tt = U22 = U42 = n__nil > n__u = u > U51
    
    partial status:
  
      pi(isNeList#) = []
      pi(n____) = []
      pi(U51#) = []
      pi(isNeList) = []
      pi(activate) = []
      pi(tt) = []
      pi(isList#) = []
      pi(U21#) = []
      pi(isList) = []
      pi(U41#) = []
      pi(U22) = []
      pi(U42) = []
      pi(U52) = []
      pi(__) = []
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

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: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(n____(V1,V2)) -> isList#(activate(V1))
p4: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p5: U21#(tt(),V2) -> isList#(activate(V2))
p6: isList#(V) -> isNeList#(activate(V))
p7: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p8: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))
p9: U41#(tt(),V2) -> isNeList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))
p5: U41#(tt(),V2) -> isNeList#(activate(V2))
p6: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p7: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p8: U21#(tt(),V2) -> isList#(activate(V2))
p9: isList#(n____(V1,V2)) -> isList#(activate(V1))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r16, r17, r18, r19, r20, r21, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isNeList#_A(x1) = x1 + (1,2)
          n_____A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (20,73)
          U51#_A(x1,x2) = ((1,0),(0,0)) x2 + (7,1)
          isNeList_A(x1) = ((1,0),(0,0)) x1 + (10,23)
          activate_A(x1) = ((1,0),(0,0)) x1 + (2,41)
          tt_A() = (21,38)
          isList#_A(x1) = ((1,0),(1,0)) x1 + (4,44)
          U41#_A(x1,x2) = ((1,0),(1,0)) x2 + (4,72)
          isList_A(x1) = x1 + (23,24)
          U21#_A(x1,x2) = ((1,0),(1,0)) x2 + (6,61)
          U22_A(x1) = ((1,0),(1,0)) x1 + (1,16)
          U42_A(x1) = (22,39)
          U52_A(x1) = (22,39)
          ___A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (21,74)
          nil_A() = (22,42)
          U11_A(x1) = ((0,0),(1,0)) x1 + (22,18)
          U21_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (6,45)
          U31_A(x1) = ((1,0),(1,0)) x1 + (1,16)
          U41_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (2,40)
          U51_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,1)) x2 + (5,19)
          isQid_A(x1) = ((1,0),(0,0)) x1 + (6,1)
          n__a_A() = (22,1)
          n__e_A() = (22,39)
          n__i_A() = (22,1)
          n__o_A() = (22,39)
          n__u_A() = (22,0)
          n__nil_A() = (22,1)
          a_A() = (22,1)
          e_A() = (22,42)
          i_A() = (22,1)
          o_A() = (23,40)
          u_A() = (23,1)
  
    precedence:
    
      a > e > U41 > isNeList > activate = isList = U21 = i > U42 > n____ = __ > isList# > U21# > U41# = n__a > U31 = n__u > tt = U22 = U52 = U51 = n__e = n__i = n__nil > isNeList# = nil = isQid = n__o > o > U51# = u > U11
    
    partial status:
  
      pi(isNeList#) = [1]
      pi(n____) = []
      pi(U51#) = []
      pi(isNeList) = []
      pi(activate) = []
      pi(tt) = []
      pi(isList#) = []
      pi(U41#) = []
      pi(isList) = []
      pi(U21#) = []
      pi(U22) = []
      pi(U42) = []
      pi(U52) = []
      pi(__) = [1]
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

The next rules are strictly ordered:

  p9

We remove them from the problem.

-- SCC decomposition.

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

p1: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))
p5: U41#(tt(),V2) -> isNeList#(activate(V2))
p6: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p7: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p8: U21#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p4: U21#(tt(),V2) -> isList#(activate(V2))
p5: isList#(V) -> isNeList#(activate(V))
p6: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p7: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))
p8: U41#(tt(),V2) -> isNeList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r16, r17, r18, r19, r20, r21, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isNeList#_A(x1) = ((1,0),(1,1)) x1 + (14,1)
          n_____A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,0)) x2 + (34,3)
          U51#_A(x1,x2) = ((0,0),(1,0)) x1 + ((1,0),(0,0)) x2 + (27,14)
          isNeList_A(x1) = x1 + (9,3)
          activate_A(x1) = ((1,0),(0,0)) x1 + (6,4)
          tt_A() = (25,1)
          isList#_A(x1) = ((1,0),(1,1)) x1 + (20,28)
          U21#_A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (2,38)
          isList_A(x1) = ((1,0),(0,0)) x1 + (17,5)
          U41#_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(1,0)) x2 + (1,12)
          U22_A(x1) = (26,2)
          U42_A(x1) = (26,2)
          U52_A(x1) = ((1,0),(1,1)) x1 + (1,1)
          ___A(x1,x2) = ((1,0),(1,1)) x1 + x2 + (35,5)
          nil_A() = (27,5)
          U11_A(x1) = ((1,0),(0,0)) x1 + (1,2)
          U21_A(x1,x2) = ((0,0),(1,0)) x2 + (27,0)
          U31_A(x1) = ((1,0),(0,0)) x1 + (1,2)
          U41_A(x1,x2) = ((1,0),(0,0)) x1 + (2,5)
          U51_A(x1,x2) = ((1,0),(0,0)) x2 + (29,30)
          isQid_A(x1) = ((1,0),(0,0)) x1 + (1,2)
          n__a_A() = (26,2)
          n__e_A() = (26,5)
          n__i_A() = (26,2)
          n__o_A() = (26,2)
          n__u_A() = (26,2)
          n__nil_A() = (26,2)
          a_A() = (27,5)
          e_A() = (27,4)
          i_A() = (27,5)
          o_A() = (26,5)
          u_A() = (27,5)
  
    precedence:
    
      n__e > isNeList = U31 = U41 > tt = U42 = isQid > isList = U11 = U21 = i > n__i > U41# > isNeList# > U51# > activate = e > U21# = n__o = a > isList# = __ > nil = n__nil > n__a > n__u = o = u > U22 > n____ = U52 = U51
    
    partial status:
  
      pi(isNeList#) = [1]
      pi(n____) = []
      pi(U51#) = []
      pi(isNeList) = []
      pi(activate) = []
      pi(tt) = []
      pi(isList#) = [1]
      pi(U21#) = []
      pi(isList) = []
      pi(U41#) = []
      pi(U22) = []
      pi(U42) = []
      pi(U52) = [1]
      pi(__) = [1, 2]
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

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: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p4: U21#(tt(),V2) -> isList#(activate(V2))
p5: isList#(V) -> isNeList#(activate(V))
p6: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p7: isNeList#(n____(V1,V2)) -> U41#(isList(activate(V1)),activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: isNeList#(n____(V1,V2)) -> U51#(isNeList(activate(V1)),activate(V2))
p2: U51#(tt(),V2) -> isList#(activate(V2))
p3: isList#(V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p5: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p6: U21#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r16, r17, r18, r19, r20, r21, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isNeList#_A(x1) = ((0,0),(1,0)) x1 + (0,1)
          n_____A(x1,x2) = x1 + x2 + (12,9)
          U51#_A(x1,x2) = ((0,0),(1,0)) x2 + (0,9)
          isNeList_A(x1) = ((0,0),(1,0)) x1 + (5,11)
          activate_A(x1) = x1 + (3,18)
          tt_A() = (0,0)
          isList#_A(x1) = ((0,0),(1,0)) x1 + (0,5)
          U21#_A(x1,x2) = ((0,0),(1,0)) x2 + (0,8)
          isList_A(x1) = x1 + (7,6)
          U22_A(x1) = (0,0)
          U42_A(x1) = ((0,0),(1,0)) x1 + (1,5)
          U52_A(x1) = (1,1)
          ___A(x1,x2) = ((1,0),(0,0)) x1 + x2 + (13,0)
          nil_A() = (2,1)
          U11_A(x1) = x1 + (1,1)
          U21_A(x1,x2) = (0,0)
          U31_A(x1) = (1,10)
          U41_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (4,9)
          U51_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (2,17)
          isQid_A(x1) = ((1,0),(0,0)) x1 + (1,1)
          n__a_A() = (1,1)
          n__e_A() = (1,1)
          n__i_A() = (1,1)
          n__o_A() = (1,1)
          n__u_A() = (1,1)
          n__nil_A() = (1,2)
          a_A() = (1,1)
          e_A() = (2,20)
          i_A() = (2,0)
          o_A() = (1,20)
          u_A() = (2,0)
  
    precedence:
    
      __ = U41 = e = i > isNeList# = isList# = U21# > nil = n__nil > U51# = activate > isNeList = isList = U31 > a > U42 = U11 = isQid = n__u > U52 = n__a = n__e = n__o > u > o > U51 > n____ = tt = U22 = U21 = n__i
    
    partial status:
  
      pi(isNeList#) = []
      pi(n____) = [1]
      pi(U51#) = []
      pi(isNeList) = []
      pi(activate) = [1]
      pi(tt) = []
      pi(isList#) = []
      pi(U21#) = []
      pi(isList) = [1]
      pi(U22) = []
      pi(U42) = []
      pi(U52) = []
      pi(__) = []
      pi(nil) = []
      pi(U11) = [1]
      pi(U21) = []
      pi(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

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: U51#(tt(),V2) -> isList#(activate(V2))
p2: isList#(V) -> isNeList#(activate(V))
p3: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p4: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p5: U21#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

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: isList#(V) -> isNeList#(activate(V))
p2: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p3: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p4: U21#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r16, r17, r18, r19, r20, r21, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isList#_A(x1) = ((1,0),(0,0)) x1 + (12,10)
          isNeList#_A(x1) = ((1,0),(1,0)) x1 + (1,1)
          activate_A(x1) = ((1,0),(1,1)) x1 + (10,45)
          n_____A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (43,39)
          U21#_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (21,11)
          isList_A(x1) = (11,47)
          tt_A() = (2,9)
          U42_A(x1) = ((1,0),(1,1)) x1 + (1,1)
          U52_A(x1) = ((0,0),(1,0)) x1 + (3,8)
          U22_A(x1) = (2,10)
          U31_A(x1) = (3,1)
          U41_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,1)) x2 + (42,42)
          isNeList_A(x1) = x1 + (32,7)
          U51_A(x1,x2) = ((0,0),(1,0)) x1 + ((1,0),(1,1)) x2 + (32,46)
          isQid_A(x1) = (33,8)
          n__a_A() = (1,1)
          n__e_A() = (3,10)
          n__i_A() = (1,1)
          n__o_A() = (3,10)
          n__u_A() = (3,10)
          ___A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (44,40)
          nil_A() = (4,1)
          U11_A(x1) = ((0,0),(1,0)) x1 + (3,6)
          U21_A(x1,x2) = ((1,0),(0,0)) x1 + (0,11)
          n__nil_A() = (3,10)
          a_A() = (2,2)
          e_A() = (3,59)
          i_A() = (2,48)
          o_A() = (3,11)
          u_A() = (12,9)
  
    precedence:
    
      U31 = n__nil > U21 > e > a > isList = tt = U52 > U42 > U51 > isList# = isNeList# = n__e = n__i = nil > activate = U41 = i > isQid = n__a = n__o = __ > n____ > U21# = isNeList = U11 > o > U22 = n__u = u
    
    partial status:
  
      pi(isList#) = []
      pi(isNeList#) = []
      pi(activate) = [1]
      pi(n____) = [1, 2]
      pi(U21#) = []
      pi(isList) = []
      pi(tt) = []
      pi(U42) = [1]
      pi(U52) = []
      pi(U22) = []
      pi(U31) = []
      pi(U41) = []
      pi(isNeList) = [1]
      pi(U51) = [2]
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(__) = [1]
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

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: isNeList#(n____(V1,V2)) -> isList#(activate(V1))
p2: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p3: U21#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p2, p3}


-- Reduction pair.

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

p1: isList#(n____(V1,V2)) -> U21#(isList(activate(V1)),activate(V2))
p2: U21#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r16, r17, r18, r19, r20, r21, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          isList#_A(x1) = ((1,0),(1,1)) x1 + (1,1)
          n_____A(x1,x2) = ((1,0),(0,0)) x1 + x2 + (48,2)
          U21#_A(x1,x2) = ((1,0),(1,1)) x2 + (8,26)
          isList_A(x1) = (5,0)
          activate_A(x1) = x1 + (6,18)
          tt_A() = (2,26)
          U42_A(x1) = (2,27)
          U52_A(x1) = ((0,0),(1,0)) x1 + (3,25)
          U22_A(x1) = ((0,0),(1,0)) x1 + (3,25)
          U31_A(x1) = ((1,0),(1,0)) x1 + (1,25)
          U41_A(x1,x2) = ((1,0),(0,0)) x1 + ((0,0),(1,0)) x2 + (0,28)
          isNeList_A(x1) = x1 + (9,15)
          U51_A(x1,x2) = ((0,0),(1,0)) x1 + (4,1)
          isQid_A(x1) = ((1,0),(0,0)) x1 + (1,16)
          n__a_A() = (3,25)
          n__e_A() = (3,1)
          n__i_A() = (3,1)
          n__o_A() = (3,27)
          n__u_A() = (3,27)
          ___A(x1,x2) = x1 + x2 + (49,1)
          nil_A() = (2,1)
          U11_A(x1) = ((0,0),(1,0)) x1 + (3,25)
          U21_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (4,1)
          n__nil_A() = (1,2)
          a_A() = (4,0)
          e_A() = (4,19)
          i_A() = (4,0)
          o_A() = (4,46)
          u_A() = (3,27)
  
    precedence:
    
      n____ = U42 = U41 = __ > a > U21# > isList# > isList > U22 = nil = U21 = n__nil > U31 > tt = U11 > activate > n__e = e > U52 = isNeList = U51 = n__a = n__i = n__u = i = o = u > n__o > isQid
    
    partial status:
  
      pi(isList#) = [1]
      pi(n____) = []
      pi(U21#) = []
      pi(isList) = []
      pi(activate) = [1]
      pi(tt) = []
      pi(U42) = []
      pi(U52) = []
      pi(U22) = []
      pi(U31) = []
      pi(U41) = []
      pi(isNeList) = []
      pi(U51) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(__) = []
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

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#(tt(),V2) -> isList#(activate(V2))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  (no SCCs)

-- Reduction pair.

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

p1: __#(__(X,Y),Z) -> __#(X,__(Y,Z))
p2: __#(__(X,Y),Z) -> __#(Y,Z)

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r32

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          __#_A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (1,1)
          ___A(x1,x2) = ((1,0),(0,0)) x1 + x2 + (2,0)
          nil_A() = (1,1)
          n_____A(x1,x2) = (1,0)
  
    precedence:
    
      __ > __# = nil = n____
    
    partial status:
  
      pi(__#) = [1]
      pi(__) = []
      pi(nil) = []
      pi(n____) = []

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: __#(__(X,Y),Z) -> __#(X,__(Y,Z))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: __#(__(X,Y),Z) -> __#(X,__(Y,Z))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt()) -> tt()
r5: U21(tt(),V2) -> U22(isList(activate(V2)))
r6: U22(tt()) -> tt()
r7: U31(tt()) -> tt()
r8: U41(tt(),V2) -> U42(isNeList(activate(V2)))
r9: U42(tt()) -> tt()
r10: U51(tt(),V2) -> U52(isList(activate(V2)))
r11: U52(tt()) -> tt()
r12: U61(tt()) -> tt()
r13: U71(tt(),P) -> U72(isPal(activate(P)))
r14: U72(tt()) -> tt()
r15: U81(tt()) -> tt()
r16: isList(V) -> U11(isNeList(activate(V)))
r17: isList(n__nil()) -> tt()
r18: isList(n____(V1,V2)) -> U21(isList(activate(V1)),activate(V2))
r19: isNeList(V) -> U31(isQid(activate(V)))
r20: isNeList(n____(V1,V2)) -> U41(isList(activate(V1)),activate(V2))
r21: isNeList(n____(V1,V2)) -> U51(isNeList(activate(V1)),activate(V2))
r22: isNePal(V) -> U61(isQid(activate(V)))
r23: isNePal(n____(I,__(P,I))) -> U71(isQid(activate(I)),activate(P))
r24: isPal(V) -> U81(isNePal(activate(V)))
r25: isPal(n__nil()) -> tt()
r26: isQid(n__a()) -> tt()
r27: isQid(n__e()) -> tt()
r28: isQid(n__i()) -> tt()
r29: isQid(n__o()) -> tt()
r30: isQid(n__u()) -> tt()
r31: nil() -> n__nil()
r32: __(X1,X2) -> n____(X1,X2)
r33: a() -> n__a()
r34: e() -> n__e()
r35: i() -> n__i()
r36: o() -> n__o()
r37: u() -> n__u()
r38: activate(n__nil()) -> nil()
r39: activate(n____(X1,X2)) -> __(X1,X2)
r40: activate(n__a()) -> a()
r41: activate(n__e()) -> e()
r42: activate(n__i()) -> i()
r43: activate(n__o()) -> o()
r44: activate(n__u()) -> u()
r45: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r32

Take the reduction pair:

  weighted path order
  
    base order:
  
      matrix interpretations:
      
        carrier: N^2
        order: lexicographic order
        interpretations:
          __#_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + (1,2)
          ___A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (2,1)
          nil_A() = (1,1)
          n_____A(x1,x2) = (1,2)
  
    precedence:
    
      __# = __ = n____ > nil
    
    partial status:
  
      pi(__#) = []
      pi(__) = []
      pi(nil) = []
      pi(n____) = []

The next rules are strictly ordered:

  p1

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