YES

Problem:
 strict:
  b(b(x1)) -> c(b(c(x1)))
  c(c(c(x1))) -> a(x1)
 weak:
  a(x1) -> a(c(b(x1)))

Proof:
 Bounds Processor:
  bound: 2
  enrichment: match-rt
  automaton:
   final states: {3,2,1}
   transitions:
    c1(7) -> 8*
    c1(25) -> 26*
    c1(27) -> 28*
    c1(59) -> 60*
    c1(84) -> 85*
    c1(5) -> 6*
    c1(103) -> 104*
    a1(60) -> 61*
    a1(39) -> 40*
    a1(52) -> 53*
    a1(50) -> 51*
    b1(102) -> 103*
    b1(6) -> 7*
    b1(83) -> 84*
    b1(58) -> 59*
    b1(105) -> 106*
    b1(70) -> 71*
    b1(120) -> 121*
    b0(3) -> 1*
    b0(2) -> 1*
    b0(1) -> 1*
    a0(1) -> 3*
    a0(3) -> 3*
    a0(2) -> 3*
    c0(2) -> 2*
    c0(1) -> 2*
    c0(3) -> 2*
    a2(122) -> 123*
    a2(162) -> 163*
    a2(152) -> 153*
    a2(168) -> 169*
    a2(136) -> 137*
    b2(194) -> 195*
    b2(196) -> 197*
    b2(166) -> 167*
    b2(178) -> 179*
    b2(134) -> 135*
    b2(176) -> 177*
    b2(150) -> 151*
    b2(87) -> 88*
    b2(205) -> 206*
    b2(160) -> 161*
    c2(88) -> 89*
    c2(161) -> 162*
    c2(151) -> 152*
    c2(206) -> 207*
    c2(167) -> 168*
    c2(135) -> 136*
    c2(86) -> 87*
    c2(115) -> 116*
    163 -> 53*
    195 -> 135*
    168 -> 178*
    162 -> 176*
    137 -> 40*
    7 -> 122,39
    104 -> 50*
    169 -> 61*
    85 -> 39*
    106 -> 7*
    28 -> 6*
    2 -> 58,50,25
    53 -> 87,26
    105 -> 115*
    52 -> 160,105
    153 -> 51*
    116 -> 87*
    6 -> 86*
    121 -> 59*
    207 -> 122*
    177 -> 161*
    26 -> 6*
    179 -> 167*
    197 -> 151*
    60 -> 166,120
    71 -> 59*
    8 -> 161,106,71,1
    123 -> 162,116
    40 -> 8,28,60,26,2
    1 -> 70,52,27
    50 -> 150,102
    3 -> 2,5
    39 -> 134,83
    122 -> 205*
    136 -> 194*
    51 -> 87,26
    152 -> 196*
    89 -> 206,135,84
    61 -> 3*
  problem:
   strict:
    c(c(c(x1))) -> a(x1)
   weak:
    a(x1) -> a(c(b(x1)))
  Matrix Interpretation Processor: dim=2
   
   interpretation:
              [1 1]     [0]
    [c](x0) = [0 1]x0 + [1],
    
              [1 0]  
    [b](x0) = [0 0]x0,
    
              [1 0]     [0]
    [a](x0) = [0 0]x0 + [1]
   orientation:
                  [1 3]     [3]    [1 0]     [0]        
    c(c(c(x1))) = [0 1]x1 + [3] >= [0 0]x1 + [1] = a(x1)
    
            [1 0]     [0]    [1 0]     [0]              
    a(x1) = [0 0]x1 + [1] >= [0 0]x1 + [1] = a(c(b(x1)))
   problem:
    strict:
     
    weak:
     a(x1) -> a(c(b(x1)))
   Qed