"TFL::IsTransposeTrivial($0.getType().cast<ShapedType>().getShape(), $1)">>;

// Constraint that checks if the reshape op is equivalent to a transpose op.
// This is true if the reshape op is a trivial reshape op, meaning no change in
// the order of non-identity dimensions.
def IsReshapeEquivalentToTranspose : Constraint<CPred<
  "TFL::IsReshapeEquivalentToTranspose("
    "$0.getType().cast<ShapedType>(),"
    "$1.getType().cast<ShapedType>())">>;

bool IsSupportedVariableType(Operation* op) {
  ShapedType type;
  if (llvm::isa<TF::ReadVariableOp>(op)) {
    type = op->getResult(0).getType().cast<ShapedType>();
  } else if (llvm::isa<TF::AssignVariableOp>(op)) {
    type = op->getOperand(1).getType().cast<ShapedType>();
  } else if (llvm::isa<TF::VarHandleOp>(op)) {
    type = op->getResult(0)
               .getType()
               .cast<ShapedType>()
               .getElementType()

LogicalResult VerifyTypesCompatibility(Operation::operand_type_range types,
                                       bool mask_one_dim, Operation *op) {
  int64_t common_rank = ShapedType::kDynamic;
  llvm::SmallVector<int64_t, 4> common_dims;
  int64_t dim_to_mask = ShapedType::kDynamic;

  // Initialize common_rank with rank of the first ranked type and verify that
  // following ranked types have the same rank.

  return shaped_type.clone(new_shape);
}

// Returns a ShapedType for a permutation and the shape of input after
// applying the permutation to the given shape through a transpose.
inline ShapedType GetTransposedType(Value input,
                                    llvm::ArrayRef<int64_t> permutation_array) {
  auto input_type = input.getType().cast<ShapedType>();
  if (permutation_array.size() != input_type.getRank()) {

// indices in `val2`.
bool HasEqualElementSize(Value val1, Value val2, ArrayRef<int> val1_indices,
                         ArrayRef<int> val2_indices) {
  ShapedType val1_shape = mlir::cast<ShapedType>(val1.getType());
  ShapedType val2_shape = mlir::cast<ShapedType>(val2.getType());
  if (!val1_shape.hasRank() || !val2_shape.hasRank()) return false;

  int val1_result = 1;
  int val2_result = 1;

      ConversionPatternRewriter& rewriter) const final {
    ShapedType operand_type = mlir::cast<ShapedType>(op.getOperand().getType());
    ShapedType update_type =
        mlir::dyn_cast_or_null<ShapedType>(op.getUpdate().getType());
    ShapedType start_indices_type = mlir::dyn_cast_or_null<ShapedType>(
        op.getStartIndices().front().getType());

  CPred<"quant::ReshapableTo1DTensor($0.getType().cast<ShapedType>())">,
  "Checks if the value dims are all ones except the right most dim">;

def ReshapeTo1DTensor : NativeCodeCall<
  "quant::ReshapeTo1DTensor($_builder, $_loc, $0)">;

def HasEqualShape : Constraint<CPred<
  "$0.getType().cast<ShapedType>().hasRank() && "
  "$1.getType().cast<ShapedType>().hasRank() && "

OpFoldResult IdentityArithmeticOpFolder(OpT arithmetic_op,
                                        ArrayRef<Attribute> operands) {
  auto lhs_type = mlir::cast<ShapedType>(arithmetic_op.getX().getType());
  auto rhs_type = mlir::cast<ShapedType>(arithmetic_op.getY().getType());
  auto result_type =
      mlir::cast<ShapedType>(arithmetic_op.getResult().getType());

  // We can fold arithmetic operation only of we can prove that we will not

// logics.
std::optional<TF::PartitionedCallOp> RegisterOperationsInFuncOp(
    StringRef func_name, PatternRewriter& rewriter, QuantizedType quant_type,
    Value input_val, ShapedType result_type,
    std::function<Operation*(PatternRewriter&, Operation*, Value, ShapedType,
                             QuantizedType)>
        quantization_operations_func) {
  Operation* input_op = input_val.getDefiningOp();

    const float ratio_threshold) {
  ElementsAttr attr;
  ShapedType type;
  InspectResult result = {};
  if (auto cst = dyn_cast<ConstOp>(inst)) {
    attr = cst.getValue();
    type = mlir::cast<ShapedType>(cst.getType());
  } else if (auto cst = dyn_cast<QConstOp>(inst)) {
    attr = cst.getValue();
    type = mlir::cast<ShapedType>(cst.getType());
  } else {
    result.can_compress = false;