(TF_MatMulOp $a, (TF_TransposeOp $b, (TF_SubOp (TF_RangeOp
             /*start=*/(TF_RankOp $b),
             /*limit=*/(TF_ConstOp TFi32<0>),
             /*delta=*/(TF_ConstOp TFi32<-1>)), (TF_ConstOp TFi32<1>))),
           $at, ConstBoolAttrTrue, $grad_a, $grad_b)>;

// Matmul with transpose on a to matmul with explicit transpose op and a not
// transposed.

  [(TF_OneHotOp:$labels $sparse_labels,
     (TF_ConstOp (GetDimSizeAsI32<1> $features, $src_op__0)),
     (TF_ConstOp (GetScalarOfType<1> $features)),
     (TF_ConstOp (GetScalarOfType<0> $features)),
     ConstantAttr<I64Attr, "1">),
   (TF_SelectV2Op:$zero_or_nan
     (TF_LogicalAndOp
       (TF_LessEqualOp
         (TF_ConstOp (GetScalarOfType<0> $sparse_labels)), $sparse_labels),

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<
  (TF_MinimumOp (TF_ConstOp:$cst $cst_val), $input),

            (TF_BitwiseXorOp $input,
              (TF_ConstOp (GetRankedScalarAttr<"", 8, "", "-1">)))>;
def : Pat<(MHLO_NotOp TF_Int16Tensor:$input),
            (TF_BitwiseXorOp $input,
              (TF_ConstOp (GetRankedScalarAttr<"", 16, "", "-1">)))>;
def : Pat<(MHLO_NotOp TF_Int32Tensor:$input),
            (TF_BitwiseXorOp $input,
              (TF_ConstOp (GetRankedScalarAttr<"", 32, "", "-1">)))>;

     $l2_shrinkage, $lr_power, $use_locking, $multiply_linear_by_lr),
  [// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
   (TF_ConstOp:$zero (GetScalarOfType<0> $lr)),
   (TF_ConstOp:$one (GetScalarOfType<1> $lr)),
   (TF_ConstOp:$two (GetScalarOfType<2> $lr)),
   (TF_AddV2Op:$grad_with_shrinkage
     $grad,
     (TF_MulOp
       $two,

// extend bias shapes to a rank of 4, e.g. 1x1x1x5.
def ConvertSubMulToMulAdd : Pat<
  (TF_MulOp
    (TF_SubOp
      (SupportedAffineOpMatcher $conv_out, $input, $weight),
      (TF_ConstOp:$sub_rhs IsFloatElementsAttr:$sub_rhs_value)),
    (TF_ConstOp:$mul_rhs IsFloatElementsAttr:$mul_rhs_value)),
  (TF_AddV2Op
    (TF_MulOp $conv_out, (ReshapeTo1DTensor $mul_rhs)),
    (TF_MulOp
      (TF_NegOp (ReshapeTo1DTensor $sub_rhs)),

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

// This pattern optimizes:
//   (x + cst1) - cst2 -> x - cst
//   (x - cst1) + cst2 -> x + cst

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

def MatrixDiagToV3 : Pat<
  (TF_MatrixDiagOp:$src $diag),
  (TF_MatrixDiagV3Op:$dest $diag, (TF_ConstOp (GetI32Attr<0>)),
    (TF_ConstOp (GetI32Attr<-1>)), (TF_ConstOp (GetI32Attr<-1>)),
    (TF_ConstOp (GetScalarOfType<0> $diag)), (GetStrAttr<"RIGHT_LEFT">)),
  [], [(CopyAttrs $src, $dest)]>;

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

     $batch_size, $drop_remainder, $parallel_copy, $batch_output_types,
     $batch_output_shapes, $unused_batch_dataset_metadata),
  (TF_MapAndBatchDatasetOp $input_dataset, $other_arguments, $batch_size,
     (TF_ConstOp (GetI64ScalarElementsAttr<1>)), $drop_remainder, $f,
        $batch_output_types, $batch_output_shapes, $preserve_cardinality,
        // TODO(kramm): Should we merge batch_dataset_metadata and

// Converts tf.Const to arith.constant for statically shaped, non-opaque constants.
// Needed for QuantizationDriver to recognize constants.
def ConvertTfConstToArithConst : Pat<
  (TF_ConstOp:$res DenseElementsAttr:$value),
  (Arith_ConstantOp $value),