(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)))>;

// Where: cst = cst2 - cst1
foreach BinaryOpPair = [[TF_AddV2Op, TF_SubOp],
                     [TF_SubOp, TF_AddV2Op]] in {
  def OptimizeConsecutive#BinaryOpPair[0]#BinaryOpPair[1] : Pat<
    (BinaryOpPair[0]
      (BinaryOpPair[1] $x, (TF_ConstOp:$cst1 $cst1_value)),
      (TF_ConstOp:$cst2 $cst2_value)),
    (BinaryOpPair[0]
      $x, (TF_SubOp  $cst2, $cst1))>;

  (MarkNoFallback (TF_AddV2Op $input, $bias_cst)),
  [(IsFusibleWithBias $input), (RankEquals<"1"> $bias_cst),
  (NoFallbackAttrNotSet $add_op)]>;

def KeepSubOp : Pat<
  (TF_SubOp:$sub_op $input, (TF_ConstOp:$bias_cst $bias)),
  (MarkNoFallback (TF_SubOp $input, $bias_cst)),
  [(IsFusibleWithBias $input), (RankEquals<"1"> $bias_cst),

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

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)]>;

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

            $x,
            (TF_MulOp:$multiplier
                $scale,
                (TF_RsqrtOp
                    (TF_AddV2Op $variance,
                              (TF_ConstOp $epsilon))))),
        (TF_SubOp $offset, (TF_MulOp $mean, $multiplier))),
     // We already guaranteed that the last five results have no use so it does
     // not matter what value we provide here for replacement.
     /*batch_mean=*/(replaceWithValue $x),

            .create<mlir::TF::NotEqualOp>(
                loc, x, y, mlir::BoolAttr::get(opb.getContext(), true))
            .getOperation();
      });

  // mlir::TF::SubOp
  py::class_<mlir::TF::SubOp>(m, "Tf_SubOp")
      .def("create",
           [](mlir::OpBuilder& opb, mlir::Location loc, mlir::Value x,
              mlir::Value y) -> mlir::Operation* {
             return opb.create<mlir::TF::SubOp>(loc, x, y).getOperation();

class Tf_NotEqualOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1: Value, arg2: Value) -> Operation: ...

class Tf_SubOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1: Value, arg2: Value) -> Operation: ...

class Type:
    def __init__(self, *args, **kwargs) -> None: ...