def LogicalNotOfGreaterEqual : Pat<
  (TF_LogicalNotOp:$src (TF_GreaterEqualOp $arg0, $arg1)),
  (TF_LessOp:$dest $arg0, $arg1), [], [(CopyAttrs $src, $dest)]>;

def LogicalNotOfLess : Pat<(
  TF_LogicalNotOp:$src (TF_LessOp $arg0, $arg1)),
  (TF_GreaterEqualOp:$dest $arg0, $arg1), [], [(CopyAttrs $src, $dest)]>;

def LogicalNotOfLessEqual : Pat<

                 .create<mlir::TF::EqualOp>(loc, x, y, opb.getBoolAttr(true))
                 .getOperation();
           });

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

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

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

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

                            IsMhloTFCompareType:$type),
            (p[0] $l, $bcast_operand, ConstBoolAttrTrue),
            [(IsTFStyleBroadcast $broadcast_dimensions, $output)]>;
}

foreach p = [[TF_GreaterEqualOp, CHLO_ComparisonDirectionValue<"GE">],
             [TF_GreaterOp, CHLO_ComparisonDirectionValue<"GT">],
             [TF_LessEqualOp, CHLO_ComparisonDirectionValue<"LE">],

   (TF_RangeOp:$range_n $zero, $n, $one),
   (TF_SubOp:$offset (TF_ExpandDimsOp $range_m, $neg_one), $range_n),
   (TF_LogicalAndOp:$indicator (TF_LessEqualOp $offset, $num_lower_or_m),
                               (TF_GreaterEqualOp $offset,
                                                  (TF_NegOp $num_upper_or_n))),

           $l, $r, (BinBroadcastDimensions $l, $r), direction,
           (CHLO_DEFAULT_COMPARISON_TYPE))>;

def : DirectComparePat<TF_GreaterOp, CHLO_ComparisonDirectionValue<"GT">>;
def : DirectComparePat<TF_GreaterEqualOp, CHLO_ComparisonDirectionValue<"GE">>;
def : DirectComparePat<TF_LessOp, CHLO_ComparisonDirectionValue<"LT">>;
def : DirectComparePat<TF_LessEqualOp, CHLO_ComparisonDirectionValue<"LE">>;

def LegalizeGreater : Pat<(TF_GreaterOp $l, $r), (TFL_GreaterOp $l, $r)>;

def LegalizeLessEqual : Pat<(TF_LessEqualOp $l, $r), (TFL_LessEqualOp $l, $r)>;
def LegalizeGreaterEqual : Pat<(TF_GreaterEqualOp $l, $r),
                               (TFL_GreaterEqualOp $l, $r)>;

// Gather in TF -> Gather in TFL with axis=0
// The 'validate_indices' attribute is deprecated.
def LegalizeGather: Pat<

    TF_IntOrFpTensor:$x,
    TF_IntOrFpTensor:$y
  );

  let results = (outs
    TF_BoolTensor:$z
  );

  TF_DerivedOperandTypeAttr T = TF_DerivedOperandTypeAttr<0>;
}

def TF_GreaterEqualOp : TF_Op<"GreaterEqual", [Pure, ResultsBroadcastableShape]>,
                        WithBroadcastableCmpOpBuilder {
  let summary = "Returns the truth value of (x >= y) element-wise.";

  let description = [{