// the problem.
def OptimizeReluSquaredDifference : Pat<
  (TFL_ReluOp (TFL_SquaredDifferenceOp $l, $r)),
  (TFL_SquaredDifferenceOp $l, $r)>;

// Optimize X^1 o X
def OptimizePow1ToIdentity : Pat<
  (TFL_PowOp $input,
    (Arith_ConstantOp ConstantAttr<RankedF32ElementsAttr<[]>, "1.0f">)),
  (replaceWithValue $input)>;

// Optimize X^2 to X*X
def OptimizePow2ToSquare : Pat<
  (TFL_PowOp $input,

  "$_builder.getStringAttr("# values #")">;

def LegalizeTensorListReserve : Pat<(TF_TensorListReserveOp:$tf_op $shape, $num_elements),
    (TFL_CustomOp (Size2InputRange $shape, $num_elements),
   (CreateStringAttr<"\"TensorListReserve\"">), (CustomOptions $tf_op))>;

def LegalizeTensorListStack : Pat<(TF_TensorListStackOp $input, $shape, $unused_num_elements),
    (TFL_CustomOp (Size2InputRange $input, $shape),

// Pattern rules for lifting ops with bias as functions
//===----------------------------------------------------------------------===//

def LiftDotGeneralWithBiasSameShape : Pat<
  (StableHLO_AddOp:$res
    (StableHLO_DotGeneralOp
        $lhs, $rhs, $dot_dimension_numbers, $precision_config),
    $bias),
  (LiftAsTFXlaCallModule<"composite_dot_general_with_bias_same_shape_fn">

    @Issue("GRADLE-3418")
    def "doesn't match if pre and suf are the same"() {
        def step = new HasPrefixAndSuffixPatternStep("pat", "pat", CASE_SENSITIVE)

        expect:
        step.matches("patpat")
        step.matches("pat-pat")
        !step.matches("")
        !step.matches("pat")
    }

def RealTensor : TensorOf<[AnySignlessInteger, AnyFloat]>;

def LowerSquareOp : Pat<(TF_SquareOp $val), (TF_MulOp $val, $val)>;

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

def LowerSquaredDifferenceOpOneComplexTensors : Pat<
  (TF_SquaredDifferenceOp ComplexTensor: $lhs, ComplexTensor:$rhs),

  "Check if the given einsum op could be converted into a XlaDotV2 op.">;

// Converts inlined Conv2D pattern to TF XlaConvV2 op. This pattern doesn't
// support non-constant weights.
def ConvertTFConv2DToXLAConvOp : Pat<
  (TF_Conv2DOp:$conv
    (TF_SubOp (TF_CastOp $input, $truncate), $input_zp),
    (TF_CastOp (TF_IdentityOp $filter), $truncate1),
    $strides, $use_cudnn, $padding, $explicit_padding,

    [(IsNchwLayoutOp $attrs)]>;

def LegalizeCompositeExactAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),

def RemoveConstIdentityOp : Pat<
  (TF_IdentityOp (TF_ConstOp $input)),
  (TF_ConstOp $input)>;

// Standardizes the Max and Min ops by moving constant value to rhs. This will
// make it easier to create Relu1 matching patterns.
def SwapMaximumOperands : Pat<
  (TF_MaximumOp (TF_ConstOp:$cst $cst_val), $input),
  (TF_MaximumOp $input, $cst)>;

def SwapMinimumOperands : Pat<

def LiftGather : Pat<
  (TF_GatherV2Op:$res $params, $indices, $axis, $batch_dims),
  (LiftAsTFPartitionedCall<"composite_gather_fn">
    (ArgumentList $params, $indices, $axis),
    (ResultList $res),
    (NamedAttributeList
      (NamedAttr<"batch_dims"> $batch_dims))),
  [(IsNotInLiftedFunc $res), (IsConstTensor $params)], [], (addBenefit 1)>;

def LiftConv3D : Pat<

def ConvertArithConstToTfConst : Pat<
  (Arith_ConstantOp:$res DenseElementsAttr:$value),
  (TF_ConstOp $value),
  [(AnyStaticShapeTensor $res)]>;

// Remove CheckNumerics op
def RemoveCheckNumerics : Pat<
  (TF_CheckNumericsOp $arg, $msg),
  (replaceWithValue $arg)>;

// Remove StopGradient op
def RemoveStopGradient : Pat<
  (TF_StopGradientOp $arg),
  (replaceWithValue $arg)>;