YES(?,O(n^2))

Problem:
 implies(not(x),y) -> or(x,y)
 implies(not(x),or(y,z)) -> implies(y,or(x,z))
 implies(x,or(y,z)) -> or(y,implies(x,z))

Proof:
 Complexity Transformation Processor:
  strict:
   implies(not(x),y) -> or(x,y)
   implies(not(x),or(y,z)) -> implies(y,or(x,z))
   implies(x,or(y,z)) -> or(y,implies(x,z))
  weak:
   
  Matrix Interpretation Processor:
   dimension: 1
   max_matrix:
    1
    interpretation:
     [or](x0, x1) = x0 + x1,
     
     [implies](x0, x1) = x0 + x1,
     
     [not](x0) = x0 + 1
    orientation:
     implies(not(x),y) = x + y + 1 >= x + y = or(x,y)
     
     implies(not(x),or(y,z)) = x + y + z + 1 >= x + y + z = implies(y,or(x,z))
     
     implies(x,or(y,z)) = x + y + z >= x + y + z = or(y,implies(x,z))
    problem:
     strict:
      implies(x,or(y,z)) -> or(y,implies(x,z))
     weak:
      implies(not(x),y) -> or(x,y)
      implies(not(x),or(y,z)) -> implies(y,or(x,z))
    Matrix Interpretation Processor:
     dimension: 2
     max_matrix:
      [1 1]
      [0 1]
      interpretation:
                      [1 1]          [0]
       [or](x0, x1) = [0 0]x0 + x1 + [1],
       
                           [1 1]     [1 1]     [0]
       [implies](x0, x1) = [0 0]x0 + [0 1]x1 + [1],
       
                   [1 1]     [1]
       [not](x0) = [0 0]x0 + [1]
      orientation:
                            [1 1]    [1 1]    [1 1]    [1]    [1 1]    [1 1]    [1 1]    [0]                     
       implies(x,or(y,z)) = [0 0]x + [0 0]y + [0 1]z + [2] >= [0 0]x + [0 0]y + [0 1]z + [2] = or(y,implies(x,z))
       
                           [1 1]    [1 1]    [2]    [1 1]        [0]          
       implies(not(x),y) = [0 0]x + [0 1]y + [1] >= [0 0]x + y + [1] = or(x,y)
       
                                 [1 1]    [1 1]    [1 1]    [3]    [1 1]    [1 1]    [1 1]    [1]                     
       implies(not(x),or(y,z)) = [0 0]x + [0 0]y + [0 1]z + [2] >= [0 0]x + [0 0]y + [0 1]z + [2] = implies(y,or(x,z))
      problem:
       strict:
        
       weak:
        implies(x,or(y,z)) -> or(y,implies(x,z))
        implies(not(x),y) -> or(x,y)
        implies(not(x),or(y,z)) -> implies(y,or(x,z))
      Qed