YES

We show the termination of the TRS R:

  __(__(X,Y),Z) -> __(X,__(Y,Z))
  __(X,nil()) -> X
  __(nil(),X) -> X
  U11(tt(),V) -> U12(isNeList(activate(V)))
  U12(tt()) -> tt()
  U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
  U22(tt(),V2) -> U23(isList(activate(V2)))
  U23(tt()) -> tt()
  U31(tt(),V) -> U32(isQid(activate(V)))
  U32(tt()) -> tt()
  U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
  U42(tt(),V2) -> U43(isNeList(activate(V2)))
  U43(tt()) -> tt()
  U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
  U52(tt(),V2) -> U53(isList(activate(V2)))
  U53(tt()) -> tt()
  U61(tt(),V) -> U62(isQid(activate(V)))
  U62(tt()) -> tt()
  U71(tt(),V) -> U72(isNePal(activate(V)))
  U72(tt()) -> tt()
  and(tt(),X) -> activate(X)
  isList(V) -> U11(isPalListKind(activate(V)),activate(V))
  isList(n__nil()) -> tt()
  isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
  isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
  isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
  isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
  isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
  isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
  isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
  isPal(n__nil()) -> tt()
  isPalListKind(n__a()) -> tt()
  isPalListKind(n__e()) -> tt()
  isPalListKind(n__i()) -> tt()
  isPalListKind(n__nil()) -> tt()
  isPalListKind(n__o()) -> tt()
  isPalListKind(n__u()) -> tt()
  isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
  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)
  isPalListKind(X) -> n__isPalListKind(X)
  and(X1,X2) -> n__and(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__isPalListKind(X)) -> isPalListKind(X)
  activate(n__and(X1,X2)) -> and(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: U11#(tt(),V) -> U12#(isNeList(activate(V)))
p4: U11#(tt(),V) -> isNeList#(activate(V))
p5: U11#(tt(),V) -> activate#(V)
p6: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p7: U21#(tt(),V1,V2) -> isList#(activate(V1))
p8: U21#(tt(),V1,V2) -> activate#(V1)
p9: U21#(tt(),V1,V2) -> activate#(V2)
p10: U22#(tt(),V2) -> U23#(isList(activate(V2)))
p11: U22#(tt(),V2) -> isList#(activate(V2))
p12: U22#(tt(),V2) -> activate#(V2)
p13: U31#(tt(),V) -> U32#(isQid(activate(V)))
p14: U31#(tt(),V) -> isQid#(activate(V))
p15: U31#(tt(),V) -> activate#(V)
p16: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p17: U41#(tt(),V1,V2) -> isList#(activate(V1))
p18: U41#(tt(),V1,V2) -> activate#(V1)
p19: U41#(tt(),V1,V2) -> activate#(V2)
p20: U42#(tt(),V2) -> U43#(isNeList(activate(V2)))
p21: U42#(tt(),V2) -> isNeList#(activate(V2))
p22: U42#(tt(),V2) -> activate#(V2)
p23: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p24: U51#(tt(),V1,V2) -> isNeList#(activate(V1))
p25: U51#(tt(),V1,V2) -> activate#(V1)
p26: U51#(tt(),V1,V2) -> activate#(V2)
p27: U52#(tt(),V2) -> U53#(isList(activate(V2)))
p28: U52#(tt(),V2) -> isList#(activate(V2))
p29: U52#(tt(),V2) -> activate#(V2)
p30: U61#(tt(),V) -> U62#(isQid(activate(V)))
p31: U61#(tt(),V) -> isQid#(activate(V))
p32: U61#(tt(),V) -> activate#(V)
p33: U71#(tt(),V) -> U72#(isNePal(activate(V)))
p34: U71#(tt(),V) -> isNePal#(activate(V))
p35: U71#(tt(),V) -> activate#(V)
p36: and#(tt(),X) -> activate#(X)
p37: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p38: isList#(V) -> isPalListKind#(activate(V))
p39: isList#(V) -> activate#(V)
p40: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p41: isList#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
p42: isList#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p43: isList#(n____(V1,V2)) -> activate#(V1)
p44: isList#(n____(V1,V2)) -> activate#(V2)
p45: isNeList#(V) -> U31#(isPalListKind(activate(V)),activate(V))
p46: isNeList#(V) -> isPalListKind#(activate(V))
p47: isNeList#(V) -> activate#(V)
p48: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p49: isNeList#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
p50: isNeList#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p51: isNeList#(n____(V1,V2)) -> activate#(V1)
p52: isNeList#(n____(V1,V2)) -> activate#(V2)
p53: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p54: isNeList#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
p55: isNeList#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p56: isNeList#(n____(V1,V2)) -> activate#(V1)
p57: isNeList#(n____(V1,V2)) -> activate#(V2)
p58: isNePal#(V) -> U61#(isPalListKind(activate(V)),activate(V))
p59: isNePal#(V) -> isPalListKind#(activate(V))
p60: isNePal#(V) -> activate#(V)
p61: isNePal#(n____(I,__(P,I))) -> and#(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
p62: isNePal#(n____(I,__(P,I))) -> and#(isQid(activate(I)),n__isPalListKind(activate(I)))
p63: isNePal#(n____(I,__(P,I))) -> isQid#(activate(I))
p64: isNePal#(n____(I,__(P,I))) -> activate#(I)
p65: isNePal#(n____(I,__(P,I))) -> isPal#(activate(P))
p66: isNePal#(n____(I,__(P,I))) -> activate#(P)
p67: isPal#(V) -> U71#(isPalListKind(activate(V)),activate(V))
p68: isPal#(V) -> isPalListKind#(activate(V))
p69: isPal#(V) -> activate#(V)
p70: isPalListKind#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
p71: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p72: isPalListKind#(n____(V1,V2)) -> activate#(V1)
p73: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p74: activate#(n__nil()) -> nil#()
p75: activate#(n____(X1,X2)) -> __#(X1,X2)
p76: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p77: activate#(n__and(X1,X2)) -> and#(X1,X2)
p78: activate#(n__a()) -> a#()
p79: activate#(n__e()) -> e#()
p80: activate#(n__i()) -> i#()
p81: activate#(n__o()) -> o#()
p82: 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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p34, p65, p67}
  {p4, p6, p7, p11, p16, p17, p21, p23, p24, p28, p37, p40, p48, p53}
  {p36, p70, p71, p72, p73, p76, p77}
  {p1, p2}


-- Reduction pair.

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

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

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r21, r32, r33, r34, r35, r36, r37, r38, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isNePal#_A(x1) = max{57, x1 + 48}
        n_____A(x1,x2) = max{x1 + 73, x2 - 4}
        ___A(x1,x2) = max{x1 + 83, x2}
        isPal#_A(x1) = max{84, x1 + 70}
        activate_A(x1) = max{11, x1 + 10}
        U71#_A(x1,x2) = max{59, x1 + 28, x2 + 58}
        isPalListKind_A(x1) = 56
        tt_A = 28
        nil_A = 30
        and_A(x1,x2) = max{x1 - 17, x2 + 10}
        n__nil_A = 29
        n__and_A(x1,x2) = max{x1 - 27, x2 + 1}
        a_A = 12
        n__a_A = 3
        e_A = 12
        n__e_A = 3
        i_A = 12
        n__i_A = 3
        o_A = 30
        n__o_A = 29
        u_A = 30
        n__u_A = 29
        n__isPalListKind_A(x1) = 46
  
    precedence:
    
      n____ = __ = isPal# = activate = U71# = isPalListKind = tt = nil = and = a = n__a = n__u > isNePal# = n__and > n__nil > n__isPalListKind > e = n__e = i = n__i = o = n__o = u
    
    partial status:
  
      pi(isNePal#) = []
      pi(n____) = []
      pi(__) = []
      pi(isPal#) = []
      pi(activate) = []
      pi(U71#) = []
      pi(isPalListKind) = []
      pi(tt) = []
      pi(nil) = []
      pi(and) = []
      pi(n__nil) = []
      pi(n__and) = [2]
      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) = []
      pi(n__isPalListKind) = []

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: isPal#(V) -> U71#(isPalListKind(activate(V)),activate(V))
p2: U71#(tt(),V) -> isNePal#(activate(V))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: 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: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p3: U21#(tt(),V1,V2) -> isList#(activate(V1))
p4: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p5: U11#(tt(),V) -> isNeList#(activate(V))
p6: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p7: U51#(tt(),V1,V2) -> isNeList#(activate(V1))
p8: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p9: U41#(tt(),V1,V2) -> isList#(activate(V1))
p10: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p11: U42#(tt(),V2) -> isNeList#(activate(V2))
p12: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p13: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p14: U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r21, r22, r23, r24, r25, r26, r27, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        U52#_A(x1,x2) = max{x1 + 143, x2 + 87}
        tt_A = 17
        isList#_A(x1) = max{159, x1 + 87}
        activate_A(x1) = max{23, x1}
        n_____A(x1,x2) = max{269, x1 + 50, x2}
        U21#_A(x1,x2,x3) = max{356, x1 + 70, x2 + 109, x3 + 87}
        and_A(x1,x2) = max{24, x2}
        isPalListKind_A(x1) = 88
        n__isPalListKind_A(x1) = 88
        U11#_A(x1,x2) = max{159, x2 + 87}
        isNeList#_A(x1) = max{147, x1 + 87}
        U51#_A(x1,x2,x3) = max{147, x1 + 62, x2 + 87, x3 + 87}
        U41#_A(x1,x2,x3) = max{356, x1 + 178, x2 + 136, x3 + 87}
        U42#_A(x1,x2) = max{356, x2 + 87}
        isList_A(x1) = max{135, x1 + 112}
        isNeList_A(x1) = max{4, x1 - 56}
        U22#_A(x1,x2) = max{356, x2 + 87}
        U23_A(x1) = max{18, x1 - 332}
        U43_A(x1) = 21
        U53_A(x1) = 18
        U12_A(x1) = x1 + 35
        U22_A(x1,x2) = max{25, x1 - 213, x2 - 101}
        U32_A(x1) = x1 + 1
        U42_A(x1,x2) = 22
        U52_A(x1,x2) = max{136, x2 - 80}
        isQid_A(x1) = max{2, x1 - 105}
        n__a_A = 123
        n__e_A = 123
        n__i_A = 123
        n__o_A = 123
        n__u_A = 123
        ___A(x1,x2) = max{269, x1 + 50, x2}
        nil_A = 23
        U11_A(x1,x2) = max{x1 + 23, x2 + 112}
        U21_A(x1,x2,x3) = max{270, x1 - 94, x2 + 24, x3 + 26}
        U31_A(x1,x2) = max{3, x1 - 84, x2 - 80}
        U41_A(x1,x2,x3) = max{213, x2 - 6, x3 - 56}
        U51_A(x1,x2,x3) = max{x1 + 119, x3 - 56}
        n__nil_A = 18
        a_A = 123
        e_A = 123
        i_A = 123
        o_A = 123
        u_A = 123
        n__and_A(x1,x2) = max{24, x2}
  
    precedence:
    
      tt = activate = and = isPalListKind = U53 = U22 = isQid = n__e = n__u = __ = e = u > n__isPalListKind > isList > n____ > nil > n__i = i > U23 > U52# = isList# = U21# = U11# = isNeList# = U51# = U41# = U42# = isNeList = U22# = U11 > U31 > U43 = U21 = o > n__o > U42 = U52 = U41 = U51 = n__nil > n__a = a > U12 = U32 > n__and
    
    partial status:
  
      pi(U52#) = []
      pi(tt) = []
      pi(isList#) = []
      pi(activate) = []
      pi(n____) = []
      pi(U21#) = []
      pi(and) = []
      pi(isPalListKind) = []
      pi(n__isPalListKind) = []
      pi(U11#) = []
      pi(isNeList#) = []
      pi(U51#) = []
      pi(U41#) = []
      pi(U42#) = []
      pi(isList) = [1]
      pi(isNeList) = []
      pi(U22#) = []
      pi(U23) = []
      pi(U43) = []
      pi(U53) = []
      pi(U12) = []
      pi(U22) = []
      pi(U32) = [1]
      pi(U42) = []
      pi(U52) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(__) = []
      pi(nil) = []
      pi(U11) = []
      pi(U21) = [3]
      pi(U31) = []
      pi(U41) = []
      pi(U51) = [1]
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []
      pi(n__and) = []

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: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p3: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p4: U11#(tt(),V) -> isNeList#(activate(V))
p5: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p6: U51#(tt(),V1,V2) -> isNeList#(activate(V1))
p7: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p8: U41#(tt(),V1,V2) -> isList#(activate(V1))
p9: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p10: U42#(tt(),V2) -> isNeList#(activate(V2))
p11: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p12: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p13: U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p3: U11#(tt(),V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p5: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p6: U42#(tt(),V2) -> isNeList#(activate(V2))
p7: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p8: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p9: U51#(tt(),V1,V2) -> isNeList#(activate(V1))
p10: U41#(tt(),V1,V2) -> isList#(activate(V1))
p11: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p12: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p13: U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r21, r22, r23, r24, r25, r26, r27, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        U52#_A(x1,x2) = max{x1 - 266, x2 + 106}
        tt_A = 373
        isList#_A(x1) = max{107, x1 + 106}
        activate_A(x1) = x1
        U11#_A(x1,x2) = x2 + 106
        isPalListKind_A(x1) = max{284, x1 - 1}
        isNeList#_A(x1) = x1 + 106
        n_____A(x1,x2) = max{177, x1 + 136, x2}
        U41#_A(x1,x2,x3) = max{239, x2 + 108, x3 + 106}
        and_A(x1,x2) = max{277, x2}
        n__isPalListKind_A(x1) = max{284, x1 - 1}
        U42#_A(x1,x2) = max{x1 - 186, x2 + 106}
        isList_A(x1) = max{293, x1 + 240}
        U51#_A(x1,x2,x3) = max{x2 + 177, x3 + 106}
        isNeList_A(x1) = x1 + 442
        U21#_A(x1,x2,x3) = max{x1 - 317, x2 + 241, x3 + 106}
        U22#_A(x1,x2) = max{x1 - 238, x2 + 106}
        U23_A(x1) = 374
        U43_A(x1) = max{394, x1 - 48}
        U53_A(x1) = 376
        U12_A(x1) = max{375, x1 - 202}
        U22_A(x1,x2) = 375
        U32_A(x1) = x1 + 1
        U42_A(x1,x2) = x2 + 395
        U52_A(x1,x2) = max{x1 + 2, x2 + 377}
        isQid_A(x1) = max{372, x1 - 1}
        n__a_A = 375
        n__e_A = 375
        n__i_A = 375
        n__o_A = 375
        n__u_A = 375
        ___A(x1,x2) = max{177, x1 + 136, x2}
        nil_A = 375
        U11_A(x1,x2) = max{292, x1 + 2, x2 + 240}
        U21_A(x1,x2,x3) = max{375, x1 - 287}
        U31_A(x1,x2) = max{x1 + 8, x2 + 374}
        U41_A(x1,x2,x3) = max{x1 - 132, x2 - 1, x3 + 396}
        U51_A(x1,x2,x3) = max{x1 + 293, x2 + 577, x3 + 442}
        n__nil_A = 375
        a_A = 375
        e_A = 375
        i_A = 375
        o_A = 375
        u_A = 375
        n__and_A(x1,x2) = max{277, x2}
  
    precedence:
    
      activate = isPalListKind = and = isQid = __ > n__i = i > U32 > u > n__u > isList > U11 > U12 = U21 > U43 = U42 = U41 = o > n__o > a > n__a > U52# = isList# = U11# = isNeList# = U41# = U42# = U51# = U21# = U22# > isNeList = nil = U31 > n__e = e > n__nil > U53 = U52 = U51 = n__and > tt = n____ = n__isPalListKind = U23 = U22
    
    partial status:
  
      pi(U52#) = []
      pi(tt) = []
      pi(isList#) = []
      pi(activate) = []
      pi(U11#) = []
      pi(isPalListKind) = []
      pi(isNeList#) = []
      pi(n____) = [1]
      pi(U41#) = []
      pi(and) = []
      pi(n__isPalListKind) = []
      pi(U42#) = []
      pi(isList) = []
      pi(U51#) = []
      pi(isNeList) = [1]
      pi(U21#) = []
      pi(U22#) = []
      pi(U23) = []
      pi(U43) = []
      pi(U53) = []
      pi(U12) = []
      pi(U22) = []
      pi(U32) = []
      pi(U42) = []
      pi(U52) = []
      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(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []
      pi(n__and) = []

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: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p3: U11#(tt(),V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p5: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p6: U42#(tt(),V2) -> isNeList#(activate(V2))
p7: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p8: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p9: U41#(tt(),V1,V2) -> isList#(activate(V1))
p10: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p11: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p12: U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p3: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p4: U22#(tt(),V2) -> isList#(activate(V2))
p5: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p6: U11#(tt(),V) -> isNeList#(activate(V))
p7: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p8: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p9: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p10: U41#(tt(),V1,V2) -> isList#(activate(V1))
p11: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p12: U42#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r21, r22, r23, r24, r25, r26, r27, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        U52#_A(x1,x2) = max{x1 + 115, x2 - 9}
        tt_A = 5
        isList#_A(x1) = max{119, x1 - 9}
        activate_A(x1) = max{8, x1}
        n_____A(x1,x2) = max{229, x1 + 218, x2}
        U21#_A(x1,x2,x3) = max{x1 + 211, x3 - 9}
        and_A(x1,x2) = max{x1 - 118, x2 + 8}
        isPalListKind_A(x1) = 8
        n__isPalListKind_A(x1) = 0
        U22#_A(x1,x2) = max{212, x2 - 9}
        isList_A(x1) = x1 + 30
        U11#_A(x1,x2) = max{x1 + 103, x2 - 9}
        isNeList#_A(x1) = max{0, x1 - 9}
        U51#_A(x1,x2,x3) = max{x1 - 7, x2 + 200, x3 - 9}
        isNeList_A(x1) = x1 + 76
        U41#_A(x1,x2,x3) = max{x1 + 113, x2 + 200, x3 - 9}
        U42#_A(x1,x2) = max{1, x1 - 1, x2 - 9}
        U23_A(x1) = max{11, x1 - 29}
        U43_A(x1) = max{65, x1 - 17}
        U53_A(x1) = max{45, x1 + 7}
        U12_A(x1) = max{6, x1 - 63}
        U22_A(x1,x2) = max{x1 + 5, x2 + 12}
        U32_A(x1) = max{6, x1 - 63}
        U42_A(x1,x2) = max{x1 - 43, x2 + 68}
        U52_A(x1,x2) = x2 + 46
        isQid_A(x1) = 65
        n__a_A = 0
        n__e_A = 9
        n__i_A = 0
        n__o_A = 6
        n__u_A = 0
        ___A(x1,x2) = max{229, x1 + 218, x2}
        nil_A = 8
        U11_A(x1,x2) = max{x1 + 22, x2 + 22}
        U21_A(x1,x2,x3) = max{259, x2 + 219, x3 + 21}
        U31_A(x1,x2) = max{65, x1 + 3}
        U41_A(x1,x2,x3) = max{x1 - 9, x2 + 39, x3 + 76}
        U51_A(x1,x2,x3) = max{x1 + 60, x2 + 9, x3 + 55}
        n__nil_A = 7
        a_A = 1
        e_A = 9
        i_A = 1
        o_A = 7
        u_A = 1
        n__and_A(x1,x2) = max{x1 - 118, x2 + 8}
  
    precedence:
    
      U52# = tt = isList# = activate = n____ = U21# = and = isPalListKind = n__isPalListKind = U22# = isList = U11# = isNeList# = U51# = isNeList = U41# = U42# = U23 = U43 = U53 = U12 = U22 = U32 = U42 = U52 = isQid = n__a = n__e = n__i = n__o = n__u = __ = nil = U11 = U21 = U31 = U41 = U51 = n__nil = a = e = i = o = u = n__and
    
    partial status:
  
      pi(U52#) = []
      pi(tt) = []
      pi(isList#) = []
      pi(activate) = []
      pi(n____) = []
      pi(U21#) = []
      pi(and) = []
      pi(isPalListKind) = []
      pi(n__isPalListKind) = []
      pi(U22#) = []
      pi(isList) = []
      pi(U11#) = []
      pi(isNeList#) = []
      pi(U51#) = []
      pi(isNeList) = []
      pi(U41#) = []
      pi(U42#) = []
      pi(U23) = []
      pi(U43) = []
      pi(U53) = []
      pi(U12) = []
      pi(U22) = []
      pi(U32) = []
      pi(U42) = []
      pi(U52) = []
      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(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []
      pi(n__and) = []

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: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p3: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p4: U22#(tt(),V2) -> isList#(activate(V2))
p5: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p6: U11#(tt(),V) -> isNeList#(activate(V))
p7: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p8: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p9: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p10: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p11: U42#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p3: U11#(tt(),V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p5: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p6: U42#(tt(),V2) -> isNeList#(activate(V2))
p7: isNeList#(n____(V1,V2)) -> U51#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p8: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p9: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p10: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p11: U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r21, r22, r23, r24, r25, r26, r27, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        U52#_A(x1,x2) = max{28, x1 + 8, x2}
        tt_A = 18
        isList#_A(x1) = max{27, x1}
        activate_A(x1) = max{25, x1}
        U11#_A(x1,x2) = max{25, x1 - 1, x2}
        isPalListKind_A(x1) = max{19, x1}
        isNeList#_A(x1) = max{2, x1}
        n_____A(x1,x2) = max{243, x1 + 166, x2}
        U41#_A(x1,x2,x3) = max{x1, x2 + 165, x3}
        and_A(x1,x2) = max{x1 + 146, x2}
        n__isPalListKind_A(x1) = max{3, x1}
        U42#_A(x1,x2) = max{x1 + 8, x2}
        isList_A(x1) = x1 + 104
        U51#_A(x1,x2,x3) = max{x2 + 142, x3}
        isNeList_A(x1) = x1 + 51
        U21#_A(x1,x2,x3) = max{x1, x2 + 140, x3}
        U22#_A(x1,x2) = max{x1 + 10, x2}
        U23_A(x1) = max{19, x1 - 242}
        U43_A(x1) = max{1, x1}
        U53_A(x1) = 19
        U12_A(x1) = x1 + 1
        U22_A(x1,x2) = max{130, x1 - 130, x2 - 138}
        U32_A(x1) = max{17, x1}
        U42_A(x1,x2) = max{76, x2 + 51}
        U52_A(x1,x2) = 165
        isQid_A(x1) = max{15, x1}
        n__a_A = 26
        n__e_A = 26
        n__i_A = 26
        n__o_A = 26
        n__u_A = 26
        ___A(x1,x2) = max{243, x1 + 166, x2}
        nil_A = 20
        U11_A(x1,x2) = max{x1 + 60, x2 + 78}
        U21_A(x1,x2,x3) = max{x1 + 80, x2 + 270, x3 + 6}
        U31_A(x1,x2) = max{x1 + 26, x2 + 26}
        U41_A(x1,x2,x3) = max{x2 + 217, x3 + 51}
        U51_A(x1,x2,x3) = max{x1 - 4, x2 + 165}
        n__nil_A = 19
        a_A = 26
        e_A = 26
        i_A = 26
        o_A = 26
        u_A = 26
        n__and_A(x1,x2) = max{x1 + 146, x2}
  
    precedence:
    
      U22 > n__nil > U52 = n__i = U51 = i > n____ = isList = __ > isNeList > n__e = e > U53 = n__o = U21 = o > and = n__u = u = n__and > n__a = a > U21# > U51# = nil > U41# > U22# > U52# = U42# > isList# > U42 = U41 > U23 > U11# > activate = isPalListKind = isNeList# = n__isPalListKind = U43 = U32 = U31 > tt > U12 > isQid = U11
    
    partial status:
  
      pi(U52#) = [2]
      pi(tt) = []
      pi(isList#) = [1]
      pi(activate) = [1]
      pi(U11#) = [2]
      pi(isPalListKind) = [1]
      pi(isNeList#) = [1]
      pi(n____) = [1, 2]
      pi(U41#) = [1, 3]
      pi(and) = [1, 2]
      pi(n__isPalListKind) = [1]
      pi(U42#) = [2]
      pi(isList) = []
      pi(U51#) = [3]
      pi(isNeList) = [1]
      pi(U21#) = [1, 3]
      pi(U22#) = [2]
      pi(U23) = []
      pi(U43) = []
      pi(U53) = []
      pi(U12) = []
      pi(U22) = []
      pi(U32) = []
      pi(U42) = []
      pi(U52) = []
      pi(isQid) = [1]
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(__) = [1, 2]
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(U31) = [2]
      pi(U41) = [3]
      pi(U51) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []
      pi(n__and) = [1, 2]

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: U52#(tt(),V2) -> isList#(activate(V2))
p2: isList#(V) -> U11#(isPalListKind(activate(V)),activate(V))
p3: U11#(tt(),V) -> isNeList#(activate(V))
p4: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p5: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p6: U42#(tt(),V2) -> isNeList#(activate(V2))
p7: U51#(tt(),V1,V2) -> U52#(isNeList(activate(V1)),activate(V2))
p8: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p9: U21#(tt(),V1,V2) -> U22#(isList(activate(V1)),activate(V2))
p10: U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p8, p9, p10}
  {p4, p5, p6}


-- Reduction pair.

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

p1: U22#(tt(),V2) -> isList#(activate(V2))
p2: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p3: U21#(tt(),V1,V2) -> U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r21, r22, r23, r24, r25, r26, r27, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        U22#_A(x1,x2) = max{x1 + 12, x2}
        tt_A = 48
        isList#_A(x1) = x1
        activate_A(x1) = max{59, x1}
        n_____A(x1,x2) = max{190, x1 + 125, x2}
        U21#_A(x1,x2,x3) = max{69, x1, x2 + 65, x3}
        and_A(x1,x2) = max{59, x2}
        isPalListKind_A(x1) = max{61, x1}
        n__isPalListKind_A(x1) = max{61, x1}
        isList_A(x1) = max{33, x1 - 2}
        U43_A(x1) = 69
        U53_A(x1) = 49
        U32_A(x1) = max{3, x1 + 1}
        U42_A(x1,x2) = max{70, x1 - 181}
        isNeList_A(x1) = max{17, x1 - 63}
        U52_A(x1,x2) = max{63, x1 - 141}
        isQid_A(x1) = max{1, x1 - 64}
        n__a_A = 113
        n__e_A = 113
        n__i_A = 113
        n__o_A = 113
        n__u_A = 113
        U23_A(x1) = 48
        U31_A(x1,x2) = max{3, x2 - 63}
        U41_A(x1,x2,x3) = max{126, x1 - 63, x2 - 123, x3 - 63}
        U51_A(x1,x2,x3) = max{127, x2 + 62, x3 - 123}
        U12_A(x1) = max{20, x1 + 1}
        U22_A(x1,x2) = x1 + 10
        ___A(x1,x2) = max{190, x1 + 125, x2}
        nil_A = 52
        U11_A(x1,x2) = max{20, x1 - 29, x2 - 62}
        U21_A(x1,x2,x3) = x2 + 67
        n__nil_A = 51
        a_A = 113
        e_A = 113
        i_A = 113
        o_A = 113
        u_A = 113
        n__and_A(x1,x2) = max{59, x2}
  
    precedence:
    
      U43 > isQid > isList = U42 = isNeList = n__o = U22 = U21 = o > U53 = U52 = n__e = U51 = U11 = e > U23 > U12 > n____ = U41 = __ > isPalListKind = n__isPalListKind > U21# > tt = U32 = U31 > U22# > isList# > activate = and = nil > u > n__u = n__nil = n__and > n__i = i > n__a = a
    
    partial status:
  
      pi(U22#) = [2]
      pi(tt) = []
      pi(isList#) = [1]
      pi(activate) = [1]
      pi(n____) = [1, 2]
      pi(U21#) = [1, 3]
      pi(and) = [2]
      pi(isPalListKind) = [1]
      pi(n__isPalListKind) = [1]
      pi(isList) = []
      pi(U43) = []
      pi(U53) = []
      pi(U32) = []
      pi(U42) = []
      pi(isNeList) = []
      pi(U52) = []
      pi(isQid) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(U23) = []
      pi(U31) = []
      pi(U41) = []
      pi(U51) = []
      pi(U12) = []
      pi(U22) = []
      pi(__) = [1, 2]
      pi(nil) = []
      pi(U11) = []
      pi(U21) = []
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []
      pi(n__and) = [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: isList#(n____(V1,V2)) -> U21#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p2: U21#(tt(),V1,V2) -> U22#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: 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)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p2: U41#(tt(),V1,V2) -> U42#(isList(activate(V1)),activate(V2))
p3: U42#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r21, r22, r23, r24, r25, r26, r27, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isNeList#_A(x1) = max{1, x1}
        n_____A(x1,x2) = max{x1 + 39, x2}
        U41#_A(x1,x2,x3) = max{x1, x2 + 37, x3}
        and_A(x1,x2) = max{27, x1 - 27, x2}
        isPalListKind_A(x1) = max{26, x1}
        activate_A(x1) = x1
        n__isPalListKind_A(x1) = max{26, x1}
        tt_A = 31
        U42#_A(x1,x2) = max{x1 - 16, x2}
        isList_A(x1) = x1 + 36
        U43_A(x1) = max{32, x1 - 99}
        U53_A(x1) = max{32, x1 - 3}
        U32_A(x1) = max{32, x1 - 29}
        U42_A(x1,x2) = max{98, x2 - 1}
        isNeList_A(x1) = max{97, x1 + 95}
        U52_A(x1,x2) = max{93, x2 + 33}
        isQid_A(x1) = x1 + 57
        n__a_A = 32
        n__e_A = 32
        n__i_A = 31
        n__o_A = 32
        n__u_A = 32
        U23_A(x1) = 32
        U31_A(x1,x2) = x2 + 57
        U41_A(x1,x2,x3) = max{x1 + 67, x2 + 37, x3 + 83}
        U51_A(x1,x2,x3) = max{x1 + 67, x2 + 94, x3 + 95}
        U12_A(x1) = max{34, x1 - 62}
        U22_A(x1,x2) = 33
        ___A(x1,x2) = max{x1 + 39, x2}
        nil_A = 32
        U11_A(x1,x2) = max{35, x2 + 33}
        U21_A(x1,x2,x3) = max{18, x1 + 14}
        n__nil_A = 32
        a_A = 32
        e_A = 32
        i_A = 31
        o_A = 32
        u_A = 32
        n__and_A(x1,x2) = max{27, x1 - 27, x2}
  
    precedence:
    
      n____ = U43 = U42 = n__i = n__u = U41 = __ = i = u > U41# > and = n__and > U42# = nil = n__nil > activate > isPalListKind = tt > isNeList# > isNeList = U11 > n__isPalListKind > U31 = o > isList = U53 = U32 = U52 = isQid = n__a = n__e = n__o = U23 = U51 = U12 = U22 = U21 = a = e
    
    partial status:
  
      pi(isNeList#) = [1]
      pi(n____) = [1, 2]
      pi(U41#) = [1, 3]
      pi(and) = [2]
      pi(isPalListKind) = [1]
      pi(activate) = [1]
      pi(n__isPalListKind) = [1]
      pi(tt) = []
      pi(U42#) = [2]
      pi(isList) = [1]
      pi(U43) = []
      pi(U53) = []
      pi(U32) = []
      pi(U42) = []
      pi(isNeList) = [1]
      pi(U52) = [2]
      pi(isQid) = [1]
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(U23) = []
      pi(U31) = []
      pi(U41) = [1, 2, 3]
      pi(U51) = [1, 2]
      pi(U12) = []
      pi(U22) = []
      pi(__) = [1, 2]
      pi(nil) = []
      pi(U11) = [2]
      pi(U21) = [1]
      pi(n__nil) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []
      pi(n__and) = [2]

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: isNeList#(n____(V1,V2)) -> U41#(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
p2: U42#(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: 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: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: activate#(n__and(X1,X2)) -> and#(X1,X2)
p3: and#(tt(),X) -> activate#(X)
p4: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p5: isPalListKind#(n____(V1,V2)) -> activate#(V1)
p6: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p7: isPalListKind#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r21, r32, r33, r34, r35, r36, r37, r38, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isPalListKind#_A(x1) = x1 + 10
        n_____A(x1,x2) = max{x1 + 16, x2}
        activate#_A(x1) = max{2, x1}
        n__and_A(x1,x2) = max{x1 + 3, x2}
        and#_A(x1,x2) = max{x1 + 1, x2}
        tt_A = 1
        n__isPalListKind_A(x1) = x1 + 10
        activate_A(x1) = max{4, x1}
        isPalListKind_A(x1) = x1 + 10
        ___A(x1,x2) = max{x1 + 16, x2}
        nil_A = 0
        and_A(x1,x2) = max{x1 + 3, x2}
        n__nil_A = 0
        a_A = 5
        n__a_A = 5
        e_A = 5
        n__e_A = 5
        i_A = 3
        n__i_A = 2
        o_A = 5
        n__o_A = 5
        u_A = 5
        n__u_A = 5
  
    precedence:
    
      isPalListKind# = n__and = n__isPalListKind = isPalListKind = and > and# > n____ = tt = __ = nil > activate > activate# > n__nil = a = n__a = e = n__e = i = n__i = o = n__o = u = n__u
    
    partial status:
  
      pi(isPalListKind#) = [1]
      pi(n____) = [1, 2]
      pi(activate#) = [1]
      pi(n__and) = [1, 2]
      pi(and#) = [1, 2]
      pi(tt) = []
      pi(n__isPalListKind) = [1]
      pi(activate) = [1]
      pi(isPalListKind) = [1]
      pi(__) = [1, 2]
      pi(nil) = []
      pi(and) = [1, 2]
      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:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: and#(tt(),X) -> activate#(X)
p3: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p4: isPalListKind#(n____(V1,V2)) -> activate#(V1)
p5: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p6: isPalListKind#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: 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: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p3: isPalListKind#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
p4: and#(tt(),X) -> activate#(X)
p5: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p6: isPalListKind#(n____(V1,V2)) -> activate#(V1)

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r21, r32, r33, r34, r35, r36, r37, r38, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isPalListKind#_A(x1) = x1
        n_____A(x1,x2) = max{9, x1 + 8, x2}
        activate#_A(x1) = max{9, x1}
        n__isPalListKind_A(x1) = max{6, x1}
        and#_A(x1,x2) = max{9, x1 + 1, x2}
        isPalListKind_A(x1) = max{6, x1}
        activate_A(x1) = max{4, x1}
        tt_A = 1
        ___A(x1,x2) = max{9, x1 + 8, x2}
        nil_A = 3
        and_A(x1,x2) = max{4, x2}
        n__nil_A = 2
        n__and_A(x1,x2) = x2
        a_A = 1
        n__a_A = 0
        e_A = 3
        n__e_A = 2
        i_A = 1
        n__i_A = 0
        o_A = 3
        n__o_A = 2
        u_A = 5
        n__u_A = 5
  
    precedence:
    
      n____ = __ > activate = nil = and > tt = n__a = n__o > n__nil = n__and = a = i = u > n__i > e = n__u > isPalListKind# = n__isPalListKind = and# = isPalListKind > activate# > n__e = o
    
    partial status:
  
      pi(isPalListKind#) = [1]
      pi(n____) = [1, 2]
      pi(activate#) = [1]
      pi(n__isPalListKind) = [1]
      pi(and#) = [1, 2]
      pi(isPalListKind) = [1]
      pi(activate) = [1]
      pi(tt) = []
      pi(__) = [1, 2]
      pi(nil) = []
      pi(and) = [2]
      pi(n__nil) = []
      pi(n__and) = [2]
      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:

  p4

We remove them from the problem.

-- SCC decomposition.

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

p1: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p3: isPalListKind#(n____(V1,V2)) -> and#(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
p4: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))
p5: isPalListKind#(n____(V1,V2)) -> activate#(V1)

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p1, p2, p4, p5}


-- Reduction pair.

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

p1: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p3: isPalListKind#(n____(V1,V2)) -> activate#(V1)
p4: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r21, r32, r33, r34, r35, r36, r37, r38, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isPalListKind#_A(x1) = x1 + 4
        n_____A(x1,x2) = max{9, x1 + 4, x2}
        activate#_A(x1) = max{3, x1}
        n__isPalListKind_A(x1) = x1 + 11
        activate_A(x1) = max{4, x1}
        ___A(x1,x2) = max{9, x1 + 4, x2}
        nil_A = 1
        and_A(x1,x2) = max{11, x2}
        tt_A = 1
        isPalListKind_A(x1) = x1 + 11
        n__a_A = 2
        n__e_A = 2
        n__i_A = 3
        n__nil_A = 0
        n__o_A = 2
        n__u_A = 2
        n__and_A(x1,x2) = max{11, x2}
        a_A = 3
        e_A = 3
        i_A = 3
        o_A = 3
        u_A = 3
  
    precedence:
    
      tt > n__a = n__e = n__nil = n__o > n____ = __ > nil > isPalListKind# = activate# = n__isPalListKind = isPalListKind = n__u > and = n__and = o > activate = n__i = a = e = i > u
    
    partial status:
  
      pi(isPalListKind#) = [1]
      pi(n____) = [1, 2]
      pi(activate#) = [1]
      pi(n__isPalListKind) = [1]
      pi(activate) = [1]
      pi(__) = [1, 2]
      pi(nil) = []
      pi(and) = [2]
      pi(tt) = []
      pi(isPalListKind) = [1]
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__nil) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__and) = [2]
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(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: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p3: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: isPalListKind#(n____(V1,V2)) -> activate#(V2)
p2: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p3: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r21, r32, r33, r34, r35, r36, r37, r38, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isPalListKind#_A(x1) = max{22, x1 + 19}
        n_____A(x1,x2) = max{x1 + 10, x2}
        activate#_A(x1) = max{18, x1 + 16}
        n__isPalListKind_A(x1) = max{21, x1 + 5}
        activate_A(x1) = max{4, x1}
        ___A(x1,x2) = max{x1 + 10, x2}
        nil_A = 5
        and_A(x1,x2) = max{11, x1 - 10, x2}
        tt_A = 1
        isPalListKind_A(x1) = max{21, x1 + 5}
        n__a_A = 2
        n__e_A = 0
        n__i_A = 0
        n__nil_A = 5
        n__o_A = 5
        n__u_A = 5
        n__and_A(x1,x2) = max{11, x1 - 10, x2}
        a_A = 3
        e_A = 1
        i_A = 1
        o_A = 5
        u_A = 5
  
    precedence:
    
      n__isPalListKind = activate = __ = and = tt = isPalListKind > isPalListKind# = n____ = nil > activate# = n__a = n__e = n__i = n__nil > n__o = n__u = n__and = a = e = i = o = u
    
    partial status:
  
      pi(isPalListKind#) = [1]
      pi(n____) = [1]
      pi(activate#) = [1]
      pi(n__isPalListKind) = []
      pi(activate) = []
      pi(__) = []
      pi(nil) = []
      pi(and) = []
      pi(tt) = []
      pi(isPalListKind) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__nil) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__and) = []
      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: activate#(n__isPalListKind(X)) -> isPalListKind#(X)
p2: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The estimated dependency graph contains the following SCCs:

  {p2}


-- Reduction pair.

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

p1: isPalListKind#(n____(V1,V2)) -> isPalListKind#(activate(V1))

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r21, r32, r33, r34, r35, r36, r37, r38, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        isPalListKind#_A(x1) = max{24, x1 + 16}
        n_____A(x1,x2) = max{x1 + 22, x2 - 1}
        activate_A(x1) = x1 + 8
        ___A(x1,x2) = max{x1 + 30, x2}
        nil_A = 8
        and_A(x1,x2) = max{10, x1 - 2, x2 + 8}
        tt_A = 10
        isPalListKind_A(x1) = 11
        n__a_A = 11
        n__e_A = 1
        n__i_A = 11
        n__nil_A = 1
        n__o_A = 1
        n__u_A = 11
        n__isPalListKind_A(x1) = 3
        n__and_A(x1,x2) = max{x1 - 9, x2 + 3}
        a_A = 12
        e_A = 8
        i_A = 12
        o_A = 8
        u_A = 12
  
    precedence:
    
      isPalListKind# = activate = __ = nil = and = tt = isPalListKind > n__a > n____ = n__e = n__i = n__nil = n__o = n__u = n__isPalListKind = n__and = a = e = i = o = u
    
    partial status:
  
      pi(isPalListKind#) = []
      pi(n____) = [1]
      pi(activate) = []
      pi(__) = []
      pi(nil) = []
      pi(and) = []
      pi(tt) = []
      pi(isPalListKind) = []
      pi(n__a) = []
      pi(n__e) = []
      pi(n__i) = []
      pi(n__nil) = []
      pi(n__o) = []
      pi(n__u) = []
      pi(n__isPalListKind) = []
      pi(n__and) = []
      pi(a) = []
      pi(e) = []
      pi(i) = []
      pi(o) = []
      pi(u) = []

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: __#(__(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  r1, r2, r3, r45

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        __#_A(x1,x2) = max{0, x1 - 5}
        ___A(x1,x2) = max{6, x1 + 4, x2}
        nil_A = 0
        n_____A(x1,x2) = max{x1 + 1, x2}
  
    precedence:
    
      __# = __ = nil = n____
    
    partial status:
  
      pi(__#) = []
      pi(__) = [1, 2]
      pi(nil) = []
      pi(n____) = [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: __#(__(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(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: 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) -> __#(Y,Z)

and R consists of:

r1: __(__(X,Y),Z) -> __(X,__(Y,Z))
r2: __(X,nil()) -> X
r3: __(nil(),X) -> X
r4: U11(tt(),V) -> U12(isNeList(activate(V)))
r5: U12(tt()) -> tt()
r6: U21(tt(),V1,V2) -> U22(isList(activate(V1)),activate(V2))
r7: U22(tt(),V2) -> U23(isList(activate(V2)))
r8: U23(tt()) -> tt()
r9: U31(tt(),V) -> U32(isQid(activate(V)))
r10: U32(tt()) -> tt()
r11: U41(tt(),V1,V2) -> U42(isList(activate(V1)),activate(V2))
r12: U42(tt(),V2) -> U43(isNeList(activate(V2)))
r13: U43(tt()) -> tt()
r14: U51(tt(),V1,V2) -> U52(isNeList(activate(V1)),activate(V2))
r15: U52(tt(),V2) -> U53(isList(activate(V2)))
r16: U53(tt()) -> tt()
r17: U61(tt(),V) -> U62(isQid(activate(V)))
r18: U62(tt()) -> tt()
r19: U71(tt(),V) -> U72(isNePal(activate(V)))
r20: U72(tt()) -> tt()
r21: and(tt(),X) -> activate(X)
r22: isList(V) -> U11(isPalListKind(activate(V)),activate(V))
r23: isList(n__nil()) -> tt()
r24: isList(n____(V1,V2)) -> U21(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r25: isNeList(V) -> U31(isPalListKind(activate(V)),activate(V))
r26: isNeList(n____(V1,V2)) -> U41(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r27: isNeList(n____(V1,V2)) -> U51(and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2))),activate(V1),activate(V2))
r28: isNePal(V) -> U61(isPalListKind(activate(V)),activate(V))
r29: isNePal(n____(I,__(P,I))) -> and(and(isQid(activate(I)),n__isPalListKind(activate(I))),n__and(isPal(activate(P)),n__isPalListKind(activate(P))))
r30: isPal(V) -> U71(isPalListKind(activate(V)),activate(V))
r31: isPal(n__nil()) -> tt()
r32: isPalListKind(n__a()) -> tt()
r33: isPalListKind(n__e()) -> tt()
r34: isPalListKind(n__i()) -> tt()
r35: isPalListKind(n__nil()) -> tt()
r36: isPalListKind(n__o()) -> tt()
r37: isPalListKind(n__u()) -> tt()
r38: isPalListKind(n____(V1,V2)) -> and(isPalListKind(activate(V1)),n__isPalListKind(activate(V2)))
r39: isQid(n__a()) -> tt()
r40: isQid(n__e()) -> tt()
r41: isQid(n__i()) -> tt()
r42: isQid(n__o()) -> tt()
r43: isQid(n__u()) -> tt()
r44: nil() -> n__nil()
r45: __(X1,X2) -> n____(X1,X2)
r46: isPalListKind(X) -> n__isPalListKind(X)
r47: and(X1,X2) -> n__and(X1,X2)
r48: a() -> n__a()
r49: e() -> n__e()
r50: i() -> n__i()
r51: o() -> n__o()
r52: u() -> n__u()
r53: activate(n__nil()) -> nil()
r54: activate(n____(X1,X2)) -> __(X1,X2)
r55: activate(n__isPalListKind(X)) -> isPalListKind(X)
r56: activate(n__and(X1,X2)) -> and(X1,X2)
r57: activate(n__a()) -> a()
r58: activate(n__e()) -> e()
r59: activate(n__i()) -> i()
r60: activate(n__o()) -> o()
r61: activate(n__u()) -> u()
r62: activate(X) -> X

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        __#_A(x1,x2) = max{x1 + 1, x2 + 1}
        ___A(x1,x2) = x2
  
    precedence:
    
      __# = __
    
    partial status:
  
      pi(__#) = [1]
      pi(__) = [2]

The next rules are strictly ordered:

  p1

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