(TF_MulOp:$alpha
        $lr,
        (TF_DivOp
          (TF_SqrtOp (TF_SubOp $one, $beta2_power)),
          (TF_SubOp $one, $beta1_power)
        )
      ),
      (TF_AddV2Op:$new_m
        (TF_MulOp $beta1, (CreateTFReadVariableOp $src_op, $grad, $m_resource)),
        (TF_MulOp (TF_SubOp $one, $beta1), $grad)
      ),
      (TF_AddV2Op:$new_v

def LowerSquaredDifferenceOpOnRealTensors : Pat<
  (TF_SquaredDifferenceOp RealTensor: $lhs, RealTensor:$rhs),
  (TF_SquareOp (TF_SubOp $lhs, $rhs))>;

def LowerSquaredDifferenceOpOneComplexTensors : Pat<
  (TF_SquaredDifferenceOp ComplexTensor: $lhs, ComplexTensor:$rhs),
  (TF_MulOp (TF_SubOp:$diff $lhs, $rhs), (TF_ConjOp $diff))>;

//===----------------------------------------------------------------------===//

// Converts inlined MatMul pattern to TF XlaDotV2 op. This pattern supports
// non-constant weights.
def ConvertTFMatMulWithTwoInputTensorsToXLADotV2Op : Pat<
  (TF_MatMulOp:$matmul
    (TF_SubOp (TF_CastOp $input, $truncate1), $input_zp),
    (TF_SubOp (TF_CastOp $weight, $truncate2), $weight_zp),
    $transpose_a, $transpose_b, $grad_a, $grad_b),
  (CreateXlaDotV2OpFromTfMatMulOp

    (TF_SubOp $beta, (TF_MulOp $m, $rsqrt)))>;
def ConvertBatchNormWithGlobalNormalization_2 : Pat<
  (TF_BatchNormWithGlobalNormalizationOp
    $t, $m, $v, $beta, $gamma, F32Attr:$variance_epsilon, ConstBoolAttrTrue:$scale_after_normalization),
  (TF_AddOp
    (TF_MulOp $t, (TF_MulOp:$mul (TF_RsqrtOp (TF_AddOp $v, (TF_ConstOp $variance_epsilon))), $gamma)),
    (TF_SubOp $beta, (TF_MulOp $m, $mul)))>;

//===----------------------------------------------------------------------===//

def AddV2OfNegLeft : Pat<
  (TF_AddV2Op:$src (TF_NegOp $arg0), $arg1), (TF_SubOp:$dest $arg1, $arg0),
  [], [(CopyAttrs $src, $dest)]>;

def AddV2OfNegRight : Pat<
  (TF_AddV2Op:$src $arg0, (TF_NegOp $arg1)), (TF_SubOp:$dest $arg0, $arg1), [],
  [(CopyAttrs $src, $dest)]>;

//===----------------------------------------------------------------------===//

                         [TF_PolygammaOp, CHLO_BroadcastPolygammaOp],
                         [TF_PowOp, CHLO_BroadcastPowOp],
                         [TF_RealDivOp, CHLO_BroadcastDivOp],
                         [TF_SubOp, CHLO_BroadcastSubOp],
                         [TF_ZetaOp, CHLO_BroadcastZetaOp]] in
  def : DirectBinaryPat<fromToBinPair[0], fromToBinPair[1]>;

def LowerRightShiftSigned :

                         [MHLO_MulOp, CHLO_BroadcastMulOp, TF_MulOp],
                         [MHLO_PowOp, CHLO_BroadcastPowOp, TF_PowOp],
                         [MHLO_SubtractOp, CHLO_BroadcastSubOp, TF_SubOp],
                         [MHLO_Atan2Op, CHLO_BroadcastAtan2Op, TF_Atan2Op]] in {
  def : Pat<(fromToBinPair[0]:$result $l, $r),
            (fromToBinPair[2] $l, $r),
            [(IsNotWithinScatterRegion $result)]>;

                        (TFL_AddOp $lhs, $rhs, TFL_AF_None)>;
def LegalizeBiasAdd : Pat<
  (TF_BiasAddOp F32Tensor:$l, F32Tensor:$r, IsDataFormatNHWC:$data_format),
  (TF_AddV2Op $l, $r)>;
def LegalizeSub : Pat<(TF_SubOp $lhs, $rhs),
                      (TFL_SubOp $lhs, $rhs, TFL_AF_None)>;
def LegalizeMul : Pat<(TF_MulOp $lhs, $rhs),
                      (TFL_MulOp $lhs, $rhs, TFL_AF_None)>;