YES
Time: 0.408

Problem:
 Equations:
  plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
  plusAC(x2,x3) -> plusAC(x3,x2)
  plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
  plusAC(x3,x2) -> plusAC(x2,x3)
 TRS:
  plusAC(x,0()) -> x
  plusAC(x,x) -> x
  plusAC(T(x),x) -> T(x)
  plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
  L(T(x)) -> L(x)
  L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
  T(T(x)) -> T(x)
  T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))

Proof:
 DP Processor:
  Equations#:
   plus{AC,#}(plusAC(x2,x3),x4) -> plus{AC,#}(x2,plusAC(x3,x4))
   plus{AC,#}(x2,x3) -> plus{AC,#}(x3,x2)
   plus{AC,#}(x2,plusAC(x3,x4)) -> plus{AC,#}(plusAC(x2,x3),x4)
   plus{AC,#}(x3,x2) -> plus{AC,#}(x2,x3)
  DPs:
   L#(T(x)) -> L#(x)
   L#(plusAC(T(y),x)) -> L#(y)
   L#(plusAC(T(y),x)) -> plus{AC,#}(x,y)
   L#(plusAC(T(y),x)) -> L#(plusAC(x,y))
   L#(plusAC(T(y),x)) -> plus{AC,#}(L(plusAC(x,y)),L(y))
   T#(plusAC(T(y),x)) -> plus{AC,#}(x,y)
   T#(plusAC(T(y),x)) -> T#(plusAC(x,y))
   T#(plusAC(T(y),x)) -> plus{AC,#}(T(plusAC(x,y)),T(y))
   plus{AC,#}(x5,plusAC(x,0())) -> plus{AC,#}(x5,x)
   plus{AC,#}(x6,plusAC(x,x)) -> plus{AC,#}(x6,x)
   plus{AC,#}(x7,plusAC(T(x),x)) -> plus{AC,#}(x7,T(x))
   plus{AC,#}(x8,plusAC(T(plusAC(x,y)),x)) -> plus{AC,#}(x8,T(plusAC(x,y)))
  Equations:
   plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
   plusAC(x2,x3) -> plusAC(x3,x2)
   plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
   plusAC(x3,x2) -> plusAC(x2,x3)
  TRS:
   plusAC(x,0()) -> x
   plusAC(x,x) -> x
   plusAC(T(x),x) -> T(x)
   plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
   L(T(x)) -> L(x)
   L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
   T(T(x)) -> T(x)
   T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
  S:
   plus{AC,#}(plusAC(x9,x10),x11) -> plus{AC,#}(x9,x10)
   plus{AC,#}(x9,plusAC(x10,x11)) -> plus{AC,#}(x10,x11)
  AC-EDG Processor:
   Equations#:
    plus{AC,#}(plusAC(x2,x3),x4) -> plus{AC,#}(x2,plusAC(x3,x4))
    plus{AC,#}(x2,x3) -> plus{AC,#}(x3,x2)
    plus{AC,#}(x2,plusAC(x3,x4)) -> plus{AC,#}(plusAC(x2,x3),x4)
    plus{AC,#}(x3,x2) -> plus{AC,#}(x2,x3)
   DPs:
    L#(T(x)) -> L#(x)
    L#(plusAC(T(y),x)) -> L#(y)
    L#(plusAC(T(y),x)) -> plus{AC,#}(x,y)
    L#(plusAC(T(y),x)) -> L#(plusAC(x,y))
    L#(plusAC(T(y),x)) -> plus{AC,#}(L(plusAC(x,y)),L(y))
    T#(plusAC(T(y),x)) -> plus{AC,#}(x,y)
    T#(plusAC(T(y),x)) -> T#(plusAC(x,y))
    T#(plusAC(T(y),x)) -> plus{AC,#}(T(plusAC(x,y)),T(y))
    plus{AC,#}(x5,plusAC(x,0())) -> plus{AC,#}(x5,x)
    plus{AC,#}(x6,plusAC(x,x)) -> plus{AC,#}(x6,x)
    plus{AC,#}(x7,plusAC(T(x),x)) -> plus{AC,#}(x7,T(x))
    plus{AC,#}(x8,plusAC(T(plusAC(x,y)),x)) -> plus{AC,#}(x8,T(plusAC(x,y)))
   Equations:
    plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
    plusAC(x2,x3) -> plusAC(x3,x2)
    plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
    plusAC(x3,x2) -> plusAC(x2,x3)
   TRS:
    plusAC(x,0()) -> x
    plusAC(x,x) -> x
    plusAC(T(x),x) -> T(x)
    plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
    L(T(x)) -> L(x)
    L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
    T(T(x)) -> T(x)
    T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
   S:
    plus{AC,#}(plusAC(x9,x10),x11) -> plus{AC,#}(x9,x10)
    plus{AC,#}(x9,plusAC(x10,x11)) -> plus{AC,#}(x10,x11)
   SCC Processor:
    #sccs: 3
    #rules: 8
    #arcs: 50/144
    Equations#:
     plus{AC,#}(plusAC(x2,x3),x4) -> plus{AC,#}(x2,plusAC(x3,x4))
     plus{AC,#}(x2,x3) -> plus{AC,#}(x3,x2)
     plus{AC,#}(x2,plusAC(x3,x4)) -> plus{AC,#}(plusAC(x2,x3),x4)
     plus{AC,#}(x3,x2) -> plus{AC,#}(x2,x3)
    DPs:
     L#(T(x)) -> L#(x)
     L#(plusAC(T(y),x)) -> L#(plusAC(x,y))
     L#(plusAC(T(y),x)) -> L#(y)
    Equations:
     plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
     plusAC(x2,x3) -> plusAC(x3,x2)
     plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
     plusAC(x3,x2) -> plusAC(x2,x3)
    TRS:
     plusAC(x,0()) -> x
     plusAC(x,x) -> x
     plusAC(T(x),x) -> T(x)
     plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
     L(T(x)) -> L(x)
     L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
     T(T(x)) -> T(x)
     T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
    S:
     plus{AC,#}(plusAC(x9,x10),x11) -> plus{AC,#}(x9,x10)
     plus{AC,#}(x9,plusAC(x10,x11)) -> plus{AC,#}(x10,x11)
    AC-DP unlabeling:
     Equations#:
      plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
      plusAC(x2,x3) -> plusAC(x3,x2)
      plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
      plusAC(x3,x2) -> plusAC(x2,x3)
     DPs:
      L#(T(x)) -> L#(x)
      L#(plusAC(T(y),x)) -> L#(plusAC(x,y))
      L#(plusAC(T(y),x)) -> L#(y)
     Equations:
      plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
      plusAC(x2,x3) -> plusAC(x3,x2)
      plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
      plusAC(x3,x2) -> plusAC(x2,x3)
     TRS:
      plusAC(x,0()) -> x
      plusAC(x,x) -> x
      plusAC(T(x),x) -> T(x)
      plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
      L(T(x)) -> L(x)
      L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
      T(T(x)) -> T(x)
      T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
     S:
      plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
      plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
     Usable Rule Processor:
      Equations#:
       plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
       plusAC(x2,x3) -> plusAC(x3,x2)
       plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
       plusAC(x3,x2) -> plusAC(x2,x3)
      DPs:
       L#(T(x)) -> L#(x)
       L#(plusAC(T(y),x)) -> L#(plusAC(x,y))
       L#(plusAC(T(y),x)) -> L#(y)
      Equations:
       plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
       plusAC(x2,x3) -> plusAC(x3,x2)
       plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
       plusAC(x3,x2) -> plusAC(x2,x3)
      TRS:
       plusAC(x,0()) -> x
       plusAC(x,x) -> x
       plusAC(T(x),x) -> T(x)
       plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
       T(T(x)) -> T(x)
       T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
      S:
       plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
       plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
      AC-KBO Processor:
       argument filtering:
        pi(plusAC) = [0,1]
        pi(0) = []
        pi(T) = [0]
        pi(L#) = 0
       precedence:
        plusAC > L# ~ T ~ 0
        weight function:
         [L#](x0) = x0,
         
         [T](x0) = 5x0 + 4,
         
         [0] = 1,
         
         [plusAC](x0, x1) = x0 + x1 + 4
         usable rules:
          plusAC(x,0()) -> x
          plusAC(x,x) -> x
          plusAC(T(x),x) -> T(x)
          plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
          T(T(x)) -> T(x)
          T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
         problem:
          Equations#:
           plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
           plusAC(x2,x3) -> plusAC(x3,x2)
           plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
           plusAC(x3,x2) -> plusAC(x2,x3)
          DPs:
           
          Equations:
           plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
           plusAC(x2,x3) -> plusAC(x3,x2)
           plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
           plusAC(x3,x2) -> plusAC(x2,x3)
          TRS:
           plusAC(x,0()) -> x
           plusAC(x,x) -> x
           plusAC(T(x),x) -> T(x)
           plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
           T(T(x)) -> T(x)
           T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
          S:
           plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
           plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
         Qed
     
     Equations#:
      plus{AC,#}(plusAC(x2,x3),x4) -> plus{AC,#}(x2,plusAC(x3,x4))
      plus{AC,#}(x2,x3) -> plus{AC,#}(x3,x2)
      plus{AC,#}(x2,plusAC(x3,x4)) -> plus{AC,#}(plusAC(x2,x3),x4)
      plus{AC,#}(x3,x2) -> plus{AC,#}(x2,x3)
     DPs:
      T#(plusAC(T(y),x)) -> T#(plusAC(x,y))
     Equations:
      plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
      plusAC(x2,x3) -> plusAC(x3,x2)
      plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
      plusAC(x3,x2) -> plusAC(x2,x3)
     TRS:
      plusAC(x,0()) -> x
      plusAC(x,x) -> x
      plusAC(T(x),x) -> T(x)
      plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
      L(T(x)) -> L(x)
      L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
      T(T(x)) -> T(x)
      T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
     S:
      plus{AC,#}(plusAC(x9,x10),x11) -> plus{AC,#}(x9,x10)
      plus{AC,#}(x9,plusAC(x10,x11)) -> plus{AC,#}(x10,x11)
     AC-DP unlabeling:
      Equations#:
       plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
       plusAC(x2,x3) -> plusAC(x3,x2)
       plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
       plusAC(x3,x2) -> plusAC(x2,x3)
      DPs:
       T#(plusAC(T(y),x)) -> T#(plusAC(x,y))
      Equations:
       plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
       plusAC(x2,x3) -> plusAC(x3,x2)
       plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
       plusAC(x3,x2) -> plusAC(x2,x3)
      TRS:
       plusAC(x,0()) -> x
       plusAC(x,x) -> x
       plusAC(T(x),x) -> T(x)
       plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
       L(T(x)) -> L(x)
       L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
       T(T(x)) -> T(x)
       T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
      S:
       plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
       plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
      Usable Rule Processor:
       Equations#:
        plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
        plusAC(x2,x3) -> plusAC(x3,x2)
        plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
        plusAC(x3,x2) -> plusAC(x2,x3)
       DPs:
        T#(plusAC(T(y),x)) -> T#(plusAC(x,y))
       Equations:
        plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
        plusAC(x2,x3) -> plusAC(x3,x2)
        plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
        plusAC(x3,x2) -> plusAC(x2,x3)
       TRS:
        plusAC(x,0()) -> x
        plusAC(x,x) -> x
        plusAC(T(x),x) -> T(x)
        plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
        T(T(x)) -> T(x)
        T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
       S:
        plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
        plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
       AC-KBO Processor:
        argument filtering:
         pi(plusAC) = [0,1]
         pi(0) = []
         pi(T) = [0]
         pi(T#) = 0
        precedence:
         plusAC > T# ~ T ~ 0
         weight function:
          [T#](x0) = x0,
          
          [T](x0) = 4x0 + 1,
          
          [0] = 4,
          
          [plusAC](x0, x1) = x0 + x1
          usable rules:
           plusAC(x,0()) -> x
           plusAC(x,x) -> x
           plusAC(T(x),x) -> T(x)
           plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
           T(T(x)) -> T(x)
           T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
          problem:
           Equations#:
            plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
            plusAC(x2,x3) -> plusAC(x3,x2)
            plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
            plusAC(x3,x2) -> plusAC(x2,x3)
           DPs:
            
           Equations:
            plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
            plusAC(x2,x3) -> plusAC(x3,x2)
            plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
            plusAC(x3,x2) -> plusAC(x2,x3)
           TRS:
            plusAC(x,0()) -> x
            plusAC(x,x) -> x
            plusAC(T(x),x) -> T(x)
            plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
            T(T(x)) -> T(x)
            T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
           S:
            plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
            plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
          Qed
      
      Equations#:
       plus{AC,#}(plusAC(x2,x3),x4) -> plus{AC,#}(x2,plusAC(x3,x4))
       plus{AC,#}(x2,x3) -> plus{AC,#}(x3,x2)
       plus{AC,#}(x2,plusAC(x3,x4)) -> plus{AC,#}(plusAC(x2,x3),x4)
       plus{AC,#}(x3,x2) -> plus{AC,#}(x2,x3)
      DPs:
       plus{AC,#}(x8,plusAC(T(plusAC(x,y)),x)) -> plus{AC,#}(x8,T(plusAC(x,y)))
       plus{AC,#}(x7,plusAC(T(x),x)) -> plus{AC,#}(x7,T(x))
       plus{AC,#}(x6,plusAC(x,x)) -> plus{AC,#}(x6,x)
       plus{AC,#}(x5,plusAC(x,0())) -> plus{AC,#}(x5,x)
      Equations:
       plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
       plusAC(x2,x3) -> plusAC(x3,x2)
       plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
       plusAC(x3,x2) -> plusAC(x2,x3)
      TRS:
       plusAC(x,0()) -> x
       plusAC(x,x) -> x
       plusAC(T(x),x) -> T(x)
       plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
       L(T(x)) -> L(x)
       L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
       T(T(x)) -> T(x)
       T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
      S:
       plus{AC,#}(plusAC(x9,x10),x11) -> plus{AC,#}(x9,x10)
       plus{AC,#}(x9,plusAC(x10,x11)) -> plus{AC,#}(x10,x11)
      AC-DP unlabeling:
       Equations#:
        plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
        plusAC(x2,x3) -> plusAC(x3,x2)
        plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
        plusAC(x3,x2) -> plusAC(x2,x3)
       DPs:
        plusAC(x8,plusAC(T(plusAC(x,y)),x)) -> plusAC(x8,T(plusAC(x,y)))
        plusAC(x7,plusAC(T(x),x)) -> plusAC(x7,T(x))
        plusAC(x6,plusAC(x,x)) -> plusAC(x6,x)
        plusAC(x5,plusAC(x,0())) -> plusAC(x5,x)
       Equations:
        plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
        plusAC(x2,x3) -> plusAC(x3,x2)
        plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
        plusAC(x3,x2) -> plusAC(x2,x3)
       TRS:
        plusAC(x,0()) -> x
        plusAC(x,x) -> x
        plusAC(T(x),x) -> T(x)
        plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
        L(T(x)) -> L(x)
        L(plusAC(T(y),x)) -> plusAC(L(plusAC(x,y)),L(y))
        T(T(x)) -> T(x)
        T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
       S:
        plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
        plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
       Usable Rule Processor:
        Equations#:
         plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
         plusAC(x2,x3) -> plusAC(x3,x2)
         plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
         plusAC(x3,x2) -> plusAC(x2,x3)
        DPs:
         plusAC(x8,plusAC(T(plusAC(x,y)),x)) -> plusAC(x8,T(plusAC(x,y)))
         plusAC(x7,plusAC(T(x),x)) -> plusAC(x7,T(x))
         plusAC(x6,plusAC(x,x)) -> plusAC(x6,x)
         plusAC(x5,plusAC(x,0())) -> plusAC(x5,x)
        Equations:
         plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
         plusAC(x2,x3) -> plusAC(x3,x2)
         plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
         plusAC(x3,x2) -> plusAC(x2,x3)
        TRS:
         plusAC(x,0()) -> x
         plusAC(x,x) -> x
         plusAC(T(x),x) -> T(x)
         plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
         T(T(x)) -> T(x)
         T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
        S:
         plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
         plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
        AC-KBO Processor:
         argument filtering:
          pi(plusAC) = [0,1]
          pi(0) = []
          pi(T) = [0]
         precedence:
          plusAC > T ~ 0
          weight function:
           [T](x0) = 2x0 + 1,
           
           [0] = 4,
           
           [plusAC](x0, x1) = x0 + x1
           usable rules:
            plusAC(x,0()) -> x
            plusAC(x,x) -> x
            plusAC(T(x),x) -> T(x)
            plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
            T(T(x)) -> T(x)
            T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
           problem:
            Equations#:
             plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
             plusAC(x2,x3) -> plusAC(x3,x2)
             plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
             plusAC(x3,x2) -> plusAC(x2,x3)
            DPs:
             
            Equations:
             plusAC(plusAC(x2,x3),x4) -> plusAC(x2,plusAC(x3,x4))
             plusAC(x2,x3) -> plusAC(x3,x2)
             plusAC(x2,plusAC(x3,x4)) -> plusAC(plusAC(x2,x3),x4)
             plusAC(x3,x2) -> plusAC(x2,x3)
            TRS:
             plusAC(x,0()) -> x
             plusAC(x,x) -> x
             plusAC(T(x),x) -> T(x)
             plusAC(T(plusAC(x,y)),x) -> T(plusAC(x,y))
             T(T(x)) -> T(x)
             T(plusAC(T(y),x)) -> plusAC(T(plusAC(x,y)),T(y))
            S:
             plusAC(plusAC(x9,x10),x11) -> plusAC(x9,x10)
             plusAC(x9,plusAC(x10,x11)) -> plusAC(x10,x11)
           Qed