YES
Input TRS:
AC symbols: or xor and
      1: xor(F(),x) -> x
      2: xor(neg(x),x) -> F()
      3: and(T(),x) -> x
      4: and(F(),x) -> F()
      5: and(x,x) -> x
      6: and(xor(x,y),z) -> xor(and(x,z),and(y,z))
      7: xor(x,x) -> F()
      8: impl(x,y) -> xor(and(x,y),xor(T(),x))
      9: or(x,y) -> xor(and(x,y),xor(x,y))
      10: equiv(x,y) -> xor(xor(T(),y),x)
      11: neg(x) -> xor(T(),x)
Number of strict rules: 11
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
     #1: #and(xor(x,y),z) -> #xor(and(x,z),and(y,z))
     #2: #and(xor(x,y),z) -> #and(x,z)
     #3: #and(xor(x,y),z) -> #and(y,z)
     #4: #xor(x,xor(y,z)) ->= #xor(xor(x,y),z)
     #5: #xor(x,xor(y,z)) ->= #xor(x,y)
     #6: #or(x,y) -> #xor(and(x,y),xor(x,y))
     #7: #or(x,y) -> #and(x,y)
     #8: #or(x,y) -> #xor(x,y)
     #9: #neg(x) -> #xor(T(),x)
     #10: #or(x,or(y,z)) ->= #or(or(x,y),z)
     #11: #or(x,or(y,z)) ->= #or(x,y)
     #12: #and(x,and(y,z)) ->= #and(and(x,y),z)
     #13: #and(x,and(y,z)) ->= #and(x,y)
     #14: #equiv(x,y) -> #xor(xor(T(),y),x)
     #15: #equiv(x,y) -> #xor(T(),y)
     #16: #impl(x,y) -> #xor(and(x,y),xor(T(),x))
     #17: #impl(x,y) -> #and(x,y)
     #18: #impl(x,y) -> #xor(T(),x)
Number of SCCs: 3, DPs: 8
  SCC { #10 #11 }
only weak rules.
Number of SCCs: 2, DPs: 6
  SCC { #4 #5 }
only weak rules.
Number of SCCs: 1, DPs: 4
  SCC { #2 #3 #12 #13 }
POLO(Sum)... POLO(max)... QLPOS... succeeded.
      T 	s: []	p: 0
      F 	s: []	p: 0
      and	s: {1,2}	p: 2
      #impl	s: 1
      equiv	s: 1
      or	s: {}	p: 0
      neg	s: []	p: 0
      impl	s: [1,2]	p: 0
      #xor	s: {}	p: 1
      #equiv	s: [1,2]	p: 0
      #or	s: {}	p: 0
      #neg	s: []	p: 0
      xor	s: {1,2}	p: 1
      #and	s: {1,2}	p: 2
    USABLE RULES: { 1..7 13 14 }
    Removed DPs: #2 #3 #13
Number of SCCs: 1, DPs: 1
  SCC { #12 }
only weak rules.
Number of SCCs: 0, DPs: 0
Next Dependency Pairs:
     #19: #xor(xor(neg(x),x),_1) -> #xor(F(),_1)
     #20: #and(and(xor(x,y),z),_1) -> #and(xor(and(x,z),and(y,z)),_1)
     #21: #xor(x,xor(y,z)) ->= #xor(xor(x,y),z)
     #22: #xor(x,xor(y,z)) ->= #xor(x,y)
     #23: #or(or(x,y),_1) -> #or(xor(and(x,y),xor(x,y)),_1)
     #24: #or(x,or(y,z)) ->= #or(or(x,y),z)
     #25: #or(x,or(y,z)) ->= #or(x,y)
     #26: #and(x,and(y,z)) ->= #and(and(x,y),z)
     #27: #and(x,and(y,z)) ->= #and(x,y)
     #28: #xor(xor(x,x),_1) -> #xor(F(),_1)
     #29: #and(and(x,x),_1) -> #and(x,_1)
     #30: #and(and(T(),x),_1) -> #and(x,_1)
     #31: #xor(xor(F(),x),_1) -> #xor(x,_1)
     #32: #and(and(F(),x),_1) -> #and(F(),_1)
Number of SCCs: 3, DPs: 14
  SCC { #23..25 }
POLO(Sum)... POLO(max)... QLPOS... succeeded.
      T 	s: []	p: 0
      F 	s: []	p: 0
      and	s: {1,2}	p: 2
      #impl	s: 1
      equiv	s: 1
      or	s: {1,2}	p: 3
      neg	s: []	p: 0
      impl	s: [1,2]	p: 0
      #xor	s: {}	p: 1
      #equiv	s: [1,2]	p: 0
      #or	s: {1,2}	p: 3
      #neg	s: []	p: 0
      xor	s: {1,2}	p: 1
      #and	s: {1,2}	p: 2
    USABLE RULES: { 1..7 9 12..14 }
    Removed DPs: #23 #25
Number of SCCs: 3, DPs: 12
  SCC { #24 }
only weak rules.
Number of SCCs: 2, DPs: 11
  SCC { #19 #21 #22 #28 #31 }
POLO(Sum)... succeeded.
      T 	w: 1
      F 	w: 1
      and	w: x1 + x2 + 8856
      #impl	w: 0
      equiv	w: 0
      or	w: x1 + x2 + 1
      neg	w: 14235
      impl	w: 0
      #xor	w: x1 + x2
      #equiv	w: 0
      #or	w: 0
      #neg	w: 0
      xor	w: x1 + x2 + 2
      #and	w: 0
    USABLE RULES: { 1 2 7 13 }
    Removed DPs: #19 #22 #28 #31
Number of SCCs: 2, DPs: 7
  SCC { #21 }
only weak rules.
Number of SCCs: 1, DPs: 6
  SCC { #20 #26 #27 #29 #30 #32 }
POLO(Sum)... POLO(max)... QLPOS... succeeded.
      T 	s: []	p: 0
      F 	s: []	p: 0
      and	s: {1,2}	p: 2
      #impl	s: 1
      equiv	s: 1
      or	s: {1,2}	p: 3
      neg	s: []	p: 0
      impl	s: [1,2]	p: 0
      #xor	s: {}	p: 1
      #equiv	s: [1,2]	p: 0
      #or	s: {1,2}	p: 3
      #neg	s: []	p: 0
      xor	s: {1,2}	p: 1
      #and	s: {1,2}	p: 2
    USABLE RULES: { 1..7 9 12..14 }
    Removed DPs: #20 #27 #29 #30 #32
Number of SCCs: 1, DPs: 1
  SCC { #26 }
only weak rules.
Number of SCCs: 0, DPs: 0