[mlir][sparse] Combining `dimOrdering`+`higherOrdering` fields into `dimToLvl`

[wrengr]

Summary

This is a major step along the way towards the new STEA design. While a great deal of this patch is simple renaming, there are several significant changes as well. I've done my best to ensure that this patch retains the previous behavior and error-conditions, even though those are at odds with the eventual intended semantics of the dimToLvl mapping. Since the majority of the compiler does not yet support non-permutations, I've also added explicit assertions in places that previously had implicitly assumed it was dealing with permutations.

[wrengr]

git-clang-format

[wrengr]

updating the STEA-documentation examples

[aartbik]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

170

even though this will be corrected by your follow up improvements, it may be worthwhile to note that the level types are applied after the dim to level translation (your improved renaming went a long way to make this more clear, but e.g. make it clear that (i,j)->(j,i) and dense, compressed is really CSC since dense applied to outer j

I thought we had that somewhere, but can't find it

[wrengr]

adding documentation for the dim/lvl distinction and how the various fields correspond

[wrengr]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

170

I added a brief discussion (further up, before describing the fields) of the dim/lvl distinction and how the fields correspond. Let me know if that's sufficient.

Fwiw, I was hoping to avoid doing too much rewriting of the STEA documentation prior to introducing the new syntax; just to avoid spending too much time on editing and rebasing churn. I really like the StableHLO documentation we wrote up, and was planning to do a wholesale replacement of the current STEA documentation with that StableHLO documentation once I get the new parser/syntax landed.

[aartbik]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

170

Yeah, I am not asking for any more rewriting at this point, no worries. This just jumped out a bit (but even then, I agree it was a pre-existing lack of explanation, not really related this changed).

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

551

SGTM

[wrengr]

rebase

[wrengr]

rebase

[Peiming]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

128–142

This is NICE!

238

How does compressed deal with potential trailing zeros in ELL?

[wrengr]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

238

This example for ELL is out of sync with how we'll actually be handling ELL going forward. For this commit I'm just doing the minimal changes necessary to keep things consistent. When I finish the commit for using the new syntax, I'll update the example to match the actual design we'll be using

mlir/include/mlir-c/Dialect/SparseTensor.h

 
 /// Checks whether the given attribute is a `sparse_tensor.encoding` attribute.
 MLIR_CAPI_EXPORTED bool
 mlirAttributeIsASparseTensorEncodingAttr(MlirAttribute attr);
 
 /// Creates a `sparse_tensor.encoding` attribute with the given parameters.
 MLIR_CAPI_EXPORTED MlirAttribute mlirSparseTensorEncodingAttrGet(
     MlirContext ctx, intptr_t lvlRank,
-    enum MlirSparseTensorDimLevelType const *lvlTypes,
-    MlirAffineMap dimOrdering, MlirAffineMap higherOrdering, int posWidth,
-    int crdWidth);
+    enum MlirSparseTensorDimLevelType const *lvlTypes, MlirAffineMap dimToLvl,
+    int posWidth, int crdWidth);
 
 /// Returns the level-rank of the `sparse_tensor.encoding` attribute.
 MLIR_CAPI_EXPORTED intptr_t
 mlirSparseTensorEncodingGetLvlRank(MlirAttribute attr);
 
 /// Returns a specified level-type of the `sparse_tensor.encoding` attribute.
 MLIR_CAPI_EXPORTED enum MlirSparseTensorDimLevelType
 mlirSparseTensorEncodingAttrGetLvlType(MlirAttribute attr, intptr_t lvl);
 
-/// Returns the dimension-ordering of the `sparse_tensor.encoding` attribute.
+/// Returns the dimension-to-level mapping of the `sparse_tensor.encoding`
+/// attribute.
 MLIR_CAPI_EXPORTED MlirAffineMap
-mlirSparseTensorEncodingAttrGetDimOrdering(MlirAttribute attr);
-
-/// Returns the higher-ordering of the `sparse_tensor.encoding` attribute.
-MLIR_CAPI_EXPORTED MlirAffineMap
-mlirSparseTensorEncodingAttrGetHigherOrdering(MlirAttribute attr);
+mlirSparseTensorEncodingAttrGetDimToLvl(MlirAttribute attr);
 
 /// Returns the position bitwidth of the `sparse_tensor.encoding` attribute.
 MLIR_CAPI_EXPORTED int
 mlirSparseTensorEncodingAttrGetPosWidth(MlirAttribute attr);
 
 /// Returns the coordinate bitwidth of the `sparse_tensor.encoding` attribute.
 MLIR_CAPI_EXPORTED int
 mlirSparseTensorEncodingAttrGetCrdWidth(MlirAttribute attr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #include "mlir/Dialect/SparseTensor/Transforms/Passes.capi.h.inc"
 
 #endif // MLIR_C_DIALECT_SPARSETENSOR_H

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

def SparseTensorEncodingAttr : SparseTensor_Attr<"SparseTensorEncoding",
   let description = [{
     An attribute to encode TACO-style information on sparsity properties
     of tensors. The encoding is eventually used by a **sparse compiler**
     pass to generate sparse code fully automatically for all tensor
     expressions that involve tensors with a sparse encoding. Compiler
     passes that run before this sparse compiler pass need to be
     aware of the semantics of tensor types with such an encoding.
 
+    Each sparse tensor comes equipped with two different sets of axes for
+    describing the tensor's multi-dimensional structure.  We use the term
+    "dimension" to refer to the axes of the semantic tensor itself; whereas,
+    we use the term "level" to refer to the axes of the storage scheme,
+    which is the operational representation of that tensor.  Therefore,
+    the fields of the encoding attribute (further explained below) satisfy
+    the following correspondences:
+
+    - Dimensions:
+        - the shape of the tensor type
+        - the `dimSlices` field
+        - the arguments of the `dimToLvl` field
+    - Levels:
+        - the results of the `dimToLvl` field
+        - the `lvlTypes` field
+
     The attribute consists of the following fields.
 
     - Level-type for each level of a tensor type:
         - **dense** : all entries along this level are stored.
         - **compressed** : only nonzeros along this level are stored.
         - **singleton** : a variant of the compressed level-format,
           for when coordinates are guaranteed to have no siblings at this level.
       By default, each level-type has the property of being unique (no
       duplicates at that level) and ordered (coordinates appear sorted
       at that level).  The following two suffixes can be used to specify
       that the level should instead be non-unique (duplicates may appear)
       and/or non-ordered (coordinates may appear unsorted).
         - **-nu** : not unique
         - **-no** : not ordered
       Currently, these suffixes (if present) must appear in this order.
       In the future, we may introduce additional level-types and
       properties, and split up how the level-format and properties are
       specified rather than using this suffix mechanism.
 
-    - An optional permutation which maps (higher-ordering)-coordinates
-      to level-coordinates; defaulting to the identity permutation.
-      For example, given a 2-d tensor with the default higher-ordering,
-      `(i, j) -> (i, j)` specifies row-wise storage and `(i, j) ->
-      (j, i)` specifies column-wise storage.
-
-      TODO: this field is called "dimOrdering" for historical reasons,
-      even though it actually operates on level-coordinates rather than
-      dimension-coordinates.
-      (This will be corrected in an upcoming change that completely
-      overhauls the syntax of this attribute.)
-
-    - An optional higher-order mapping from dimension-coordinates to
-      a higher-order coordinate space; defaulting to the identity map.
-      This is applied before the `dimOrdering`, thus we have the composite:
-      dimCoords --higherOrdering--> hoCoords --dimOrdering--> lvlCoords.
-      The higher-order mapping is used to define block-sparse storage,
-      jagged-diagonal (JDS/ELL/ITPACK) storage, etc.
-
-      For example, given a 2-d tensor, the mapping
+    - An optional affine map from dimension-coordinates to level-coordinates;
+      defaulting to the identity map.  For example, given a 2-d tensor:
+      `(i, j) -> (i, j)` specifies row-wise storage, `(i, j) -> (j, i)`
+      specifies column-wise storage, and
       `(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)`
-      imposes an higher-order partitioning into 2x3 blocks along the
-      matrix layout.  For block-sparsity, blocks are typically stored
-      with compression while dense storage is used within each block
+      specifies 2x3 block-sparsity.  For block-sparsity, blocks are typically
+      stored with compression while dense storage is used within each block
       (although hybrid schemes are possible as well).
 
       TODO: the following example is out-of-date and will be implemented
       in a different manner than described here.
       (This will be corrected in an upcoming change that completely
       overhauls the syntax of this attribute.)
 
-      The higher-order mapping also provides a notion of "counting a
+      The dimToLvl mapping also provides a notion of "counting a
       dimension", where every stored element with the same coordinate
       is mapped to a new slice.  For instance, ELL storage of a 2-d
       tensor can be defined with the mapping `(i, j) -> (#i, i, j)`
       using the notation of [Chou20].  Lacking the `#` symbol in MLIR's
       affine mapping, we use a free symbol `c` to define such counting,
       together with a constant that denotes the number of resulting
       slices.  For example, the mapping `(i, j)[c] -> (c * 3 * i, i, j)`
       with the level-types `["dense", "dense", "compressed"]` denotes ELL
let description = [{
     #SortedCOO = #sparse_tensor.encoding<{
       lvlTypes = [ "compressed-nu", "singleton" ]
     }>
     ... tensor<?x?xf64, #SortedCOO> ...
 
     // Doubly compressed sparse column storage with specific bitwidths.
     #DCSC = #sparse_tensor.encoding<{
       lvlTypes = [ "compressed", "compressed" ],
-      dimOrdering = affine_map<(i, j) -> (j, i)>,
+      dimToLvl = affine_map<(i, j) -> (j, i)>,
       posWidth = 32,
       crdWidth = 8
     }>
     ... tensor<8x8xf64, #DCSC> ...
 
     // Block sparse row storage (2x3 blocks).
     #BCSR = #sparse_tensor.encoding<{
       lvlTypes = [ "compressed", "compressed", "dense", "dense" ],
-      dimOrdering  = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>,
-      higherOrdering = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)>
+      dimToLvl = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)>
     }>
     ... tensor<20x30xf32, #BCSR> ...
 
     // ELL storage (4 jagged diagonals, i.e., at most 4 nonzeros per row).
     #ELL = #sparse_tensor.encoding<{
       lvlTypes = [ "dense", "dense", "compressed" ],
-      dimOrdering  = affine_map<(ii, i, j) -> (ii, i, j)>,
-      higherOrdering = affine_map<(i, j)[c] -> (c * 4 * i, i, j)>
+      dimToLvl = affine_map<(i, j)[c] -> (c * 4 * i, i, j)>
     }>
     ... tensor<?x?xf64, #ELL> ...
 
     // CSR slice (offset = 0, size = 4, stride = 1 on the first dimension;
     // offset = 0, size = 8, and a dynamic stride on the second dimension).
     #CSR_SLICE = #sparse_tensor.encoding<{
       lvlTypes = [ "dense", "compressed" ],
       slice = [ (0, 4, 1), (0, 8, ?) ]
     }>
     ... tensor<?x?xf64, #CSC_SLICE> ...
 
     ```
   }];
 
   // Data in sparse tensor encoding.
   let parameters = (
     ins
     // A level-type for each level of the sparse storage.
     ArrayRefParameter<
       "::mlir::sparse_tensor::DimLevelType",
       "level-types"
       >: $lvlTypes,
-    // A permutation from (higher-ordering)-coordinates to level-coordinates.
-    "AffineMap":$dimOrdering,
-    // A mapping from dimension-coordinates to (higher-ordering)-coordinates.
-    "AffineMap":$higherOrdering,
+    // A mapping from dimension-coordinates to level-coordinates.
+    "AffineMap":$dimToLvl,
     // The required bitwidth for position storage.
     "unsigned":$posWidth,
     // The required bitwidth for coordinate storage.
     "unsigned":$crdWidth,
     // A slice attribute for each dimension of the tensor type.
+    // FIXME: The name used here is `dimSlices`, however the
+    // parser/printer uses the name `slice` instead.  Therefore
+    // the parser/printer need to be updated to match.
     ArrayRefParameter<
       "::mlir::sparse_tensor::SparseTensorDimSliceAttr",
       "per dimension slice metadata"
       >: $dimSlices
   );
 
   let builders = [
     AttrBuilder<(ins "ArrayRef<::mlir::sparse_tensor::DimLevelType>":$lvlTypes,
-                     "AffineMap":$dimOrdering,
-                     "AffineMap":$higherOrdering,
+                     "AffineMap":$dimToLvl,
                      "unsigned":$posWidth,
                      "unsigned":$crdWidth), [{
-      return $_get($_ctxt, lvlTypes,
-                         dimOrdering,
-                         higherOrdering,
-                         posWidth,
-                         crdWidth,
-                         ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr>{});
+      return $_get($_ctxt, lvlTypes, dimToLvl, posWidth, crdWidth,
     }]>
   ];
 
   let extraClassDeclaration = [{
     //
     // Factory methods.
     //
 
-    /// Constructs a new encoding with the dimOrdering and higherOrdering
-    /// reset to the default/identity.
-    SparseTensorEncodingAttr withoutOrdering() const;
+    /// Constructs a new encoding with the given dimToLvl mapping,
+    /// and all other fields inherited from `this`.
+    SparseTensorEncodingAttr withDimToLvl(AffineMap dimToLvl) const;
+    SparseTensorEncodingAttr withDimToLvl(SparseTensorEncodingAttr enc) const;
+
+    /// Constructs a new encoding with dimToLvl reset to the default/identity,
+    /// and all other fields inherited from `this`.
+    SparseTensorEncodingAttr withoutDimToLvl() const;
+
+    /// Constructs a new encoding with the given pointer and index
+    /// bitwidths, and all other fields inherited from `this`.
+    SparseTensorEncodingAttr withBitWidths(unsigned posWidth, unsigned crdWidth) const;
 
-    /// Constructs a new encoding with the pointer and index bitwidth
-    /// reset to the default.
+    /// Constructs a new encoding with the pointer and index bitwidths
+    /// reset to the default, and all other fields inherited from `this`.
     SparseTensorEncodingAttr withoutBitWidths() const;
 
     //
-    // lvlTypes methods.
+    // Rank methods.
     //
 
+    /// Returns the expected number of tensor dimensions.  Asserts that
+    /// the encoding is non-null (since no fixed result is valid for every
+    /// dense-tensor).
+    ::mlir::sparse_tensor::Dimension getDimRank() const;
+
     /// Returns the number of storage levels.  Asserts that the encoding
-    /// is non-null (since there is no fixed result that's valid for
-    /// every dense-tensor).
+    /// is non-null (since no fixed result is valid for every dense-tensor).
     ::mlir::sparse_tensor::Level getLvlRank() const;
 
+    //
+    // lvlTypes methods.
+    //
+
     /// Safely looks up the level-type for the requested level.  (Returns
     /// `DimLevelType::Dense` for the null encoding, since dense-tensors
     /// are always all-dense.)
     ::mlir::sparse_tensor::DimLevelType getLvlType(::mlir::sparse_tensor::Level l) const;
 
     bool isDenseLvl(::mlir::sparse_tensor::Level l) const { return isDenseDLT(getLvlType(l)); }
     bool isCompressedLvl(::mlir::sparse_tensor::Level l) const { return isCompressedDLT(getLvlType(l)); }
     bool isCompressedWithHiLvl(::mlir::sparse_tensor::Level l) const { return isCompressedWithHiDLT(getLvlType(l)); }
     bool isSingletonLvl(::mlir::sparse_tensor::Level l) const { return isSingletonDLT(getLvlType(l)); }
     bool isOrderedLvl(::mlir::sparse_tensor::Level l) const { return isOrderedDLT(getLvlType(l)); }
     bool isUniqueLvl(::mlir::sparse_tensor::Level l) const { return isUniqueDLT(getLvlType(l)); }
 
     /// Returns true if every level is dense.  Also returns true for
     /// the null encoding (since dense-tensors are always all-dense).
     bool isAllDense() const;
 
     /// Returns true if every level is ordered.  Also returns true for
     /// the null encoding (since dense-tensors are always all-ordered).
     bool isAllOrdered() const;
 
     //
-    // dimOrdering/higherOrdering methods.
+    // dimToLvl methods.
     //
 
-    /// Returns true if the encoding has an identity dimension ordering.
+    /// Returns true if the dimToLvl mapping is the identity.
+    /// Also returns true for the null encoding (since dense-tensors
+    /// always have the identity mapping).
+    bool isIdentity() const;
+
+    /// Returns true if the dimToLvl mapping is a permutation.
     /// Also returns true for the null encoding (since dense-tensors
-    /// always have the identity ordering).
-    bool hasIdDimOrdering() const;
+    /// always have the identity mapping).
+    bool isPermutation() const;
 
     //
     // posWidth/crdWidth methods.
     //
 
     /// Returns the type for position storage based on posWidth.
     /// Asserts that the encoding is non-null (since there's nowhere
     /// to get the `MLIRContext` from).

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorType.h

 /// this means that dense-tensors should always return the same answers
 /// as sparse-tensors with a default encoding.  But it additionally means
 /// that the answers should be normalized, so that there's no way to
 /// distinguish between non-provided data (which is filled in by default)
 /// vs explicitly-provided data which equals the defaults.
 ///
 class SparseTensorType {
 public:
-  // We memoize `lvlRank` and `dim2lvl` to avoid repeating the
+  // We memoize `lvlRank` and `dimToLvl` to avoid repeating the
   // conditionals throughout the rest of the class.
   SparseTensorType(RankedTensorType rtp)
       : rtp(rtp), enc(getSparseTensorEncoding(rtp)),
         lvlRank(enc ? enc.getLvlRank() : getDimRank()),
-        dim2lvl(enc.hasIdDimOrdering() ? AffineMap() : enc.getDimOrdering()) {
+        dimToLvl(enc.isIdentity() ? AffineMap() : enc.getDimToLvl()) {
     assert(rtp && "got null RankedTensorType");
     assert((!isIdentity() || getDimRank() == lvlRank) && "Rank mismatch");
   }
 
   SparseTensorType(ShapedType stp, SparseTensorEncodingAttr enc)
       : SparseTensorType(
             RankedTensorType::get(stp.getShape(), stp.getElementType(), enc)) {}
 
   // Copy-assignment would be implicitly deleted (because our fields
   // are const), so we explicitly delete it for clarity.
   SparseTensorType &operator=(const SparseTensorType &) = delete;
   // So we must explicitly define the copy-ctor to silence -Wdeprecated-copy.
   SparseTensorType(const SparseTensorType &) = default;
 
+  //
+  // Factory methods.
+  //
+
   /// Constructs a new `SparseTensorType` with the same dimension-shape
   /// and element type, but with the encoding replaced by the given encoding.
   SparseTensorType withEncoding(SparseTensorEncodingAttr newEnc) const {
     return SparseTensorType(rtp, newEnc);
   }
 
   /// Constructs a new `SparseTensorType` with the same dimension-shape
   /// and element type, but with the encoding replaced by
-  /// `getEncoding().withoutOrdering()`.
-  SparseTensorType withoutOrdering() const {
-    return withEncoding(enc.withoutOrdering());
+  /// `getEncoding().withDimToLvl(dimToLvl)`.
+  SparseTensorType withDimToLvl(AffineMap dimToLvl) const {
+    return withEncoding(enc.withDimToLvl(dimToLvl));
+  }
+
+  SparseTensorType withDimToLvl(SparseTensorEncodingAttr dimToLvlEnc) const {
+    return withEncoding(enc.withDimToLvl(dimToLvlEnc));
+  }
+
+  SparseTensorType withDimToLvl(const SparseTensorType &dimToLvlSTT) const {
+    return withDimToLvl(dimToLvlSTT.getEncoding());
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withoutDimToLvl()`.
+  SparseTensorType withoutDimToLvl() const {
+    return withEncoding(enc.withoutDimToLvl());
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withBitWidths(posWidth, crdWidth)`.
+  SparseTensorType withBitWidths(unsigned posWidth, unsigned crdWidth) const {
+    return withEncoding(enc.withBitWidths(posWidth, crdWidth));
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withoutBitWidths()`.
+  SparseTensorType withoutBitWidths() const {
+    return withEncoding(enc.withoutBitWidths());
   }
 
+  //
+  // Other methods.
+  //
+
   /// Allow implicit conversion to `RankedTensorType`, `ShapedType`,
   /// and `Type`.  These are implicit to help alleviate the impedance
   /// mismatch for code that has not been converted to use `SparseTensorType`
   /// directly.  Once more of the sparse compiler has been converted to
   /// using `SparseTensorType`, we may want to make these explicit instead.
   ///
   /// WARNING: This user-defined-conversion method causes overload
   /// ambiguity whenever passing a `SparseTensorType` directly to a
public:
   bool isAllDense() const { return enc.isAllDense(); }
 
   /// Returns true for tensors where every level is ordered.
   /// (This is always true for dense-tensors.)
   bool isAllOrdered() const { return enc.isAllOrdered(); }
 
   /// Returns true if the dimToLvl mapping is the identity.
   /// (This is always true for dense-tensors.)
-  bool isIdentity() const { return !dim2lvl; }
+  bool isIdentity() const { return !dimToLvl; }
+
+  /// Returns true if the dimToLvl mapping is a permutation.
+  /// (This is always true for dense-tensors.)
+  bool isPermutation() const { return enc.isPermutation(); }
 
   /// Returns the dimToLvl mapping (or the null-map for the identity).
   /// If you intend to compare the results of this method for equality,
-  /// see `hasSameDimToLvlMap` instead.
-  AffineMap getDimToLvlMap() const { return dim2lvl; }
+  /// see `hasSameDimToLvl` instead.
+  AffineMap getDimToLvl() const { return dimToLvl; }
 
   /// Returns the dimToLvl mapping, where the identity map is expanded out
   /// into a full `AffineMap`.  This method is provided as a convenience,
-  /// but for most purposes other methods (`isIdentity`, `getDimToLvlMap`,
+  /// but for most purposes other methods (`isIdentity`, `getDimToLvl`,
   /// etc) will be more helpful.
-  AffineMap getExpandedDimToLvlMap() const {
-    return dim2lvl
-               ? dim2lvl
+  AffineMap getExpandedDimToLvl() const {
+    return dimToLvl
+               ? dimToLvl
                : AffineMap::getMultiDimIdentityMap(getDimRank(), getContext());
   }
 
   /// Returns true iff the two types have the same mapping.  This method
   /// takes care to handle identity maps properly, so it should be preferred
-  /// over using `getDimToLvlMap` followed by `AffineMap::operator==`.
-  bool hasSameDimToLvlMap(const SparseTensorType &other) const {
+  /// over using `getDimToLvl` followed by `AffineMap::operator==`.
+  bool hasSameDimToLvl(const SparseTensorType &other) const {
     // If the maps are the identity, then we need to check the rank
     // to be sure they're the same size identity.  (And since identity
     // means dimRank==lvlRank, we use lvlRank as a minor optimization.)
     return isIdentity() ? (other.isIdentity() && lvlRank == other.lvlRank)
-                        : (dim2lvl == other.dim2lvl);
+                        : (dimToLvl == other.dimToLvl);
   }
 
   /// Returns the dimension-rank.
   Dimension getDimRank() const { return rtp.getRank(); }
 
   /// Returns the level-rank.
   Level getLvlRank() const { return lvlRank; }
 
public:
   }
 
 private:
   // These two must be const, to ensure coherence of the memoized fields.
   const RankedTensorType rtp;
   const SparseTensorEncodingAttr enc;
   // Memoized to avoid frequent redundant conditionals.
   const Level lvlRank;
-  const AffineMap dim2lvl;
+  const AffineMap dimToLvl;
 };
 
 /// Convenience method to abbreviate wrapping `getRankedTensorType`.
 template <typename T>
 inline SparseTensorType getSparseTensorType(T t) {
   return SparseTensorType(getRankedTensorType(t));
 }
 
 } // namespace sparse_tensor
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORTYPE_H_

mlir/lib/Bindings/Python/DialectSparseTensor.cpp

py::enum_<MlirSparseTensorDimLevelType>(m, "DimLevelType", py::module_local())
       .value("compressed-hi-nu-no",
              MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU_NO);
 
   mlir_attribute_subclass(m, "EncodingAttr",
                           mlirAttributeIsASparseTensorEncodingAttr)
       .def_classmethod(
           "get",
           [](py::object cls, std::vector<MlirSparseTensorDimLevelType> lvlTypes,
-             std::optional<MlirAffineMap> dimOrdering,
-             std::optional<MlirAffineMap> higherOrdering, int posWidth,
-             int crdWidth, MlirContext context) {
+             std::optional<MlirAffineMap> dimToLvl, int posWidth, int crdWidth,
+             MlirContext context) {
             return cls(mlirSparseTensorEncodingAttrGet(
                 context, lvlTypes.size(), lvlTypes.data(),
-                dimOrdering ? *dimOrdering : MlirAffineMap{nullptr},
-                higherOrdering ? *higherOrdering : MlirAffineMap{nullptr},
-                posWidth, crdWidth));
+                dimToLvl ? *dimToLvl : MlirAffineMap{nullptr}, posWidth,
+                crdWidth));
           },
-          py::arg("cls"), py::arg("lvl_types"), py::arg("dim_ordering"),
-          py::arg("higher_ordering"), py::arg("pos_width"),
-          py::arg("crd_width"), py::arg("context") = py::none(),
+          py::arg("cls"), py::arg("lvl_types"), py::arg("dim_to_lvl"),
+          py::arg("pos_width"), py::arg("crd_width"),
+          py::arg("context") = py::none(),
           "Gets a sparse_tensor.encoding from parameters.")
       .def_property_readonly(
           "lvl_types",
           [](MlirAttribute self) {
             const int lvlRank = mlirSparseTensorEncodingGetLvlRank(self);
             std::vector<MlirSparseTensorDimLevelType> ret;
             ret.reserve(lvlRank);
             for (int l = 0; l < lvlRank; ++l)
               ret.push_back(mlirSparseTensorEncodingAttrGetLvlType(self, l));
             return ret;
           })
       .def_property_readonly(
-          "dim_ordering",
+          "dim_to_lvl",
           [](MlirAttribute self) -> std::optional<MlirAffineMap> {
-            MlirAffineMap ret =
-                mlirSparseTensorEncodingAttrGetDimOrdering(self);
-            if (mlirAffineMapIsNull(ret))
-              return {};
-            return ret;
-          })
-      .def_property_readonly(
-          "higher_ordering",
-          [](MlirAttribute self) -> std::optional<MlirAffineMap> {
-            MlirAffineMap ret =
-                mlirSparseTensorEncodingAttrGetHigherOrdering(self);
+            MlirAffineMap ret = mlirSparseTensorEncodingAttrGetDimToLvl(self);
             if (mlirAffineMapIsNull(ret))
               return {};
             return ret;
           })
       .def_property_readonly("pos_width",
                              mlirSparseTensorEncodingAttrGetPosWidth)
       .def_property_readonly("crd_width",
                              mlirSparseTensorEncodingAttrGetCrdWidth);
 }
 
 PYBIND11_MODULE(_mlirDialectsSparseTensor, m) {
   m.doc() = "MLIR SparseTensor dialect.";
   populateDialectSparseTensorSubmodule(m);
 }

mlir/lib/CAPI/Dialect/SparseTensor.cpp

static_cast<int>(MLIR_SPARSE_TENSOR_DIM_LEVEL_DENSE) ==
         static_cast<int>(MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU_NO) ==
             static_cast<int>(DimLevelType::SingletonNuNo),
     "MlirSparseTensorDimLevelType (C-API) and DimLevelType (C++) mismatch");
 
 bool mlirAttributeIsASparseTensorEncodingAttr(MlirAttribute attr) {
   return isa<SparseTensorEncodingAttr>(unwrap(attr));
 }
 
-MlirAttribute mlirSparseTensorEncodingAttrGet(
-    MlirContext ctx, intptr_t lvlRank,
-    MlirSparseTensorDimLevelType const *lvlTypes, MlirAffineMap dimOrdering,
-    MlirAffineMap higherOrdering, int posWidth, int crdWidth) {
+MlirAttribute
+mlirSparseTensorEncodingAttrGet(MlirContext ctx, intptr_t lvlRank,
+                                MlirSparseTensorDimLevelType const *lvlTypes,
+                                MlirAffineMap dimToLvl, int posWidth,
+                                int crdWidth) {
   SmallVector<DimLevelType> cppLvlTypes;
   cppLvlTypes.reserve(lvlRank);
   for (intptr_t l = 0; l < lvlRank; ++l)
     cppLvlTypes.push_back(static_cast<DimLevelType>(lvlTypes[l]));
   return wrap(SparseTensorEncodingAttr::get(
-      unwrap(ctx), cppLvlTypes, unwrap(dimOrdering), unwrap(higherOrdering),
-      posWidth, crdWidth));
+      unwrap(ctx), cppLvlTypes, unwrap(dimToLvl), posWidth, crdWidth));
 }
 
-MlirAffineMap mlirSparseTensorEncodingAttrGetDimOrdering(MlirAttribute attr) {
-  return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getDimOrdering());
-}
-
-MlirAffineMap
-mlirSparseTensorEncodingAttrGetHigherOrdering(MlirAttribute attr) {
-  return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getHigherOrdering());
+MlirAffineMap mlirSparseTensorEncodingAttrGetDimToLvl(MlirAttribute attr) {
+  return wrap(cast<SparseTensorEncodingAttr>(unwrap(attr)).getDimToLvl());
 }
 
 intptr_t mlirSparseTensorEncodingGetLvlRank(MlirAttribute attr) {
   return cast<SparseTensorEncodingAttr>(unwrap(attr)).getLvlRank();
 }
 
 MlirSparseTensorDimLevelType
 mlirSparseTensorEncodingAttrGetLvlType(MlirAttribute attr, intptr_t lvl) {

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

Type SparseTensorEncodingAttr::getPosType() const {
   return detail::getIntegerOrIndexType(getContext(), getPosWidth());
 }
 
 Type SparseTensorEncodingAttr::getCrdType() const {
   assert(getImpl() && "Uninitialized SparseTensorEncodingAttr");
   return detail::getIntegerOrIndexType(getContext(), getCrdWidth());
 }
 
-SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutOrdering() const {
-  return SparseTensorEncodingAttr::get(getContext(), getLvlTypes(), AffineMap(),
-                                       AffineMap(), getPosWidth(),
-                                       getCrdWidth());
+SparseTensorEncodingAttr
+SparseTensorEncodingAttr::withDimToLvl(AffineMap dimToLvl) const {
+  assert(getImpl() && "Uninitialized SparseTensorEncodingAttr");
+  return SparseTensorEncodingAttr::get(getContext(), getLvlTypes(), dimToLvl,
+                                       getPosWidth(), getCrdWidth());
+}
+
+SparseTensorEncodingAttr
+SparseTensorEncodingAttr::withDimToLvl(SparseTensorEncodingAttr enc) const {
+  return withDimToLvl(enc ? enc.getDimToLvl() : AffineMap());
+}
+
+SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutDimToLvl() const {
+  return withDimToLvl(AffineMap());
+}
+
+SparseTensorEncodingAttr
+SparseTensorEncodingAttr::withBitWidths(unsigned posWidth,
+                                        unsigned crdWidth) const {
+  assert(getImpl() && "Uninitialized SparseTensorEncodingAttr");
+  return SparseTensorEncodingAttr::get(getContext(), getLvlTypes(),
+                                       getDimToLvl(), posWidth, crdWidth);
 }
 
 SparseTensorEncodingAttr SparseTensorEncodingAttr::withoutBitWidths() const {
-  return SparseTensorEncodingAttr::get(
-      getContext(), getLvlTypes(), getDimOrdering(), getHigherOrdering(), 0, 0);
+  return withBitWidths(0, 0);
 }
 
 bool SparseTensorEncodingAttr::isAllDense() const {
   return !getImpl() || llvm::all_of(getLvlTypes(), isDenseDLT);
 }
 
 bool SparseTensorEncodingAttr::isAllOrdered() const {
   return !getImpl() || llvm::all_of(getLvlTypes(), isOrderedDLT);
 }
 
-bool SparseTensorEncodingAttr::hasIdDimOrdering() const {
-  return !getImpl() || !getDimOrdering() || getDimOrdering().isIdentity();
+bool SparseTensorEncodingAttr::isIdentity() const {
+  return !getImpl() || !getDimToLvl() || getDimToLvl().isIdentity();
+}
+
+bool SparseTensorEncodingAttr::isPermutation() const {
+  return !getImpl() || !getDimToLvl() || getDimToLvl().isPermutation();
+}
+
+Dimension SparseTensorEncodingAttr::getDimRank() const {
+  assert(getImpl() && "Uninitialized SparseTensorEncodingAttr");
+  const auto dimToLvl = getDimToLvl();
+  return dimToLvl ? dimToLvl.getNumDims() : getLvlRank();
 }
 
 Level SparseTensorEncodingAttr::getLvlRank() const {
   assert(getImpl() && "Uninitialized SparseTensorEncodingAttr");
   return getLvlTypes().size();
 }
 
 DimLevelType SparseTensorEncodingAttr::getLvlType(Level l) const {
#define ERROR_IF(COND, MSG)                                                    \
   }
 
   RETURN_ON_FAIL(parser.parseLess())
   RETURN_ON_FAIL(parser.parseLBrace())
 
   // Process the data from the parsed dictionary value into struct-like data.
   SmallVector<DimLevelType> lvlTypes;
   SmallVector<SparseTensorDimSliceAttr> slices;
-  AffineMap dimOrd = {};
-  AffineMap higherOrd = {};
+  AffineMap dimToLvl = {};
   unsigned posWidth = 0;
   unsigned crdWidth = 0;
 
   StringRef attrName;
   // Exactly 6 keys.
-  SmallVector<StringRef, 6> keys = {"lvlTypes", "dimOrdering", "higherOrdering",
-                                    "posWidth", "crdWidth",    "slice"};
+  SmallVector<StringRef, 6> keys = {"lvlTypes", "dimToLvl", "posWidth",
+                                    "crdWidth", "slice"};
   while (succeeded(parser.parseOptionalKeyword(&attrName))) {
     if (!llvm::is_contained(keys, attrName)) {
       parser.emitError(parser.getNameLoc(), "unexpected key: ") << attrName;
       return {};
     }
 
     // Consume the `=` after keys
     RETURN_ON_FAIL(parser.parseEqual())
if (attrName == "lvlTypes") {
         if (auto optDLT = parseDLT(strVal)) {
           lvlTypes.push_back(optDLT.value());
         } else {
           parser.emitError(parser.getNameLoc(), "unexpected level-type: ")
               << strVal;
           return {};
         }
       }
-    } else if (attrName == "dimOrdering") {
-      Attribute attr;
-      RETURN_ON_FAIL(parser.parseAttribute(attr))
-      auto affineAttr = llvm::dyn_cast<AffineMapAttr>(attr);
-      ERROR_IF(!affineAttr, "expected an affine map for dimension ordering")
-      dimOrd = affineAttr.getValue();
-    } else if (attrName == "higherOrdering") {
+    } else if (attrName == "dimToLvl") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
       auto affineAttr = llvm::dyn_cast<AffineMapAttr>(attr);
-      ERROR_IF(!affineAttr, "expected an affine map for higher ordering")
-      higherOrd = affineAttr.getValue();
+      ERROR_IF(!affineAttr, "expected an affine map for dimToLvl")
+      dimToLvl = affineAttr.getValue();
     } else if (attrName == "posWidth") {
       Attribute attr;
       RETURN_ON_FAIL(parser.parseAttribute(attr))
       auto intAttr = llvm::dyn_cast<IntegerAttr>(attr);
       ERROR_IF(!intAttr, "expected an integral position bitwidth")
       posWidth = intAttr.getInt();
     } else if (attrName == "crdWidth") {
       Attribute attr;
#define ERROR_IF(COND, MSG)                                                    \
 
   RETURN_ON_FAIL(parser.parseRBrace())
   RETURN_ON_FAIL(parser.parseGreater())
 #undef ERROR_IF
 #undef RETURN_ON_FAIL
 
   // Construct struct-like storage for attribute.
   return parser.getChecked<SparseTensorEncodingAttr>(
-      parser.getContext(), lvlTypes, dimOrd, higherOrd, posWidth, crdWidth,
-      slices);
+      parser.getContext(), lvlTypes, dimToLvl, posWidth, crdWidth, slices);
 }
 
 void SparseTensorEncodingAttr::print(AsmPrinter &printer) const {
   // Print the struct-like storage in dictionary fashion.
   printer << "<{ lvlTypes = [ ";
   llvm::interleaveComma(getLvlTypes(), printer, [&](DimLevelType dlt) {
     printer << "\"" << toMLIRString(dlt) << "\"";
   });
   printer << " ]";
   // Print remaining members only for non-default values.
-  if (!hasIdDimOrdering())
-    printer << ", dimOrdering = affine_map<" << getDimOrdering() << ">";
-  if (getHigherOrdering())
-    printer << ", higherOrdering = affine_map<" << getHigherOrdering() << ">";
+  if (!isIdentity())
+    printer << ", dimToLvl = affine_map<" << getDimToLvl() << ">";
   if (getPosWidth())
     printer << ", posWidth = " << getPosWidth();
   if (getCrdWidth())
     printer << ", crdWidth = " << getCrdWidth();
   if (!getDimSlices().empty()) {
     printer << ", slice = [ ";
     llvm::interleaveComma(getDimSlices(), printer,
                           [&](SparseTensorDimSliceAttr attr) {
                             // Calls SparseTensorDimSliceAttr::print directly to
                             // skip mnemonic.
                             attr.print(printer);
                           });
     printer << " ]";
   }
 
   printer << " }>";
 }
 
 LogicalResult SparseTensorEncodingAttr::verify(
     function_ref<InFlightDiagnostic()> emitError,
-    ArrayRef<DimLevelType> lvlTypes, AffineMap dimOrdering,
-    AffineMap higherOrdering, unsigned posWidth, unsigned crdWidth,
-    ArrayRef<SparseTensorDimSliceAttr> dimSlices) {
+    ArrayRef<DimLevelType> lvlTypes, AffineMap dimToLvl, unsigned posWidth,
+    unsigned crdWidth, ArrayRef<SparseTensorDimSliceAttr> dimSlices) {
   if (!acceptBitWidth(posWidth))
     return emitError() << "unexpected position bitwidth: " << posWidth;
   if (!acceptBitWidth(crdWidth))
     return emitError() << "unexpected coordinate bitwidth: " << crdWidth;
   // Before we can check that the level-rank is consistent/coherent
   // across all fields, we need to define it.  The source-of-truth for
   // the `getLvlRank` method is the length of the level-types array,
   // since it must always be provided and have full rank; therefore we
   // use that same source-of-truth here.
   const Level lvlRank = lvlTypes.size();
   if (lvlRank == 0)
     return emitError() << "expected a non-empty array for lvlTypes";
-  if (dimOrdering) {
-    if (!dimOrdering.isPermutation())
-      return emitError()
-             << "expected a permutation affine map for dimension ordering";
-    if (dimOrdering.getNumResults() != lvlRank)
+  // We save `dimRank` here because we'll also need it to verify `dimSlices`.
+  const Dimension dimRank = dimToLvl ? dimToLvl.getNumDims() : lvlRank;
+  if (dimToLvl) {
+    if (dimToLvl.getNumResults() != lvlRank)
       return emitError()
-             << "level-rank mismatch between dimOrdering and lvlTypes";
+             << "level-rank mismatch between dimToLvl and lvlTypes: "
+             << dimToLvl.getNumResults() << " != " << lvlRank;
+    // TODO: The following is attempting to match the old error-conditions
+    // from prior to merging dimOrdering and higherOrdering into dimToLvl.
+    // That is, we currently require `dimToLvl` to be either a permutation
+    // (as when higherOrdering is the identity) or expansive (as per the
+    // constraints on higherOrdering).  However, those constraints do
+    // not match the intended semantics of `dimToLvl`.  As we improve the
+    // compiler to actually handle non-permutations, we need to update these
+    // checks to match what is actually supported.  In particular, this is
+    // where we'll have to check that when `lvlToDim` is provided then it
+    // is indeed an inverse of `dimToLvl`, and when it isn't provided then
+    // it can be automatically inferred.
+    if (dimRank == lvlRank && !dimToLvl.isPermutation())
+      return emitError() << "expected a permutation affine map for dimToLvl";
+    if (dimRank > lvlRank)
+      return emitError() << "unexpected dimToLvl mapping from " << dimRank
+                         << " to " << lvlRank;
   }
-  if (higherOrdering) {
-    if (higherOrdering.getNumDims() >= higherOrdering.getNumResults())
-      return emitError() << "unexpected higher ordering mapping from "
-                         << higherOrdering.getNumDims() << " to "
-                         << higherOrdering.getNumResults();
-    if (higherOrdering.getNumResults() != lvlRank)
+  if (!dimSlices.empty()) {
+    if (dimSlices.size() != dimRank)
       return emitError()
-             << "level-rank mismatch between higherOrdering and lvlTypes";
-  }
-  if (!dimSlices.empty() && dimSlices.size() != lvlRank) {
-    return emitError() << "level-rank mismatch between dimSlices and lvlTypes";
+             << "dimension-rank mismatch between dimSlices and dimToLvl: "
+             << dimSlices.size() << " != " << dimRank;
+    // Compiler support for `dimSlices` currently requires that the two
+    // ranks agree.  (However, it does allow `dimToLvl` to be a permutation.)
+    if (dimRank != lvlRank)
+      return emitError()
+             << "dimSlices expected dimension-rank to match level-rank: "
+             << dimRank << " != " << lvlRank;
   }
   return success();
 }
 
 #define RETURN_FAILURE_IF_FAILED(X)                                            \
   if (failed(X)) {                                                             \
     return failure();                                                          \
   }
 
 LogicalResult SparseTensorEncodingAttr::verifyEncoding(
     ArrayRef<DynSize> dimShape, Type elementType,
     function_ref<InFlightDiagnostic()> emitError) const {
   // Check structural integrity.  In particular, this ensures that the
   // level-rank is coherent across all the fields.
-  RETURN_FAILURE_IF_FAILED(verify(emitError, getLvlTypes(), getDimOrdering(),
-                                  getHigherOrdering(), getPosWidth(),
-                                  getCrdWidth(), getDimSlices()))
+  RETURN_FAILURE_IF_FAILED(verify(emitError, getLvlTypes(), getDimToLvl(),
+                                  getPosWidth(), getCrdWidth(), getDimSlices()))
   // Check integrity with tensor type specifics.  In particular, we
   // need only check that the dimension-rank of the tensor agrees with
   // the dimension-rank of the encoding.
   const Dimension dimRank = dimShape.size();
   if (dimRank == 0)
     return emitError() << "expected non-scalar sparse tensor";
-  if (const auto higherOrdering = getHigherOrdering()) {
-    if (higherOrdering.getNumDims() != dimRank)
-      return emitError() << "expected an affine map with " << dimRank
-                         << " dimensions for higher ordering";
-    // TODO: verification of higher ordering contents
-  } else if (dimRank != getLvlRank()) {
-    return emitError() << "expected an array of size " << dimRank
-                       << " for lvlTypes";
-  }
+  if (getDimRank() != dimRank)
+    return emitError()
+           << "dimension-rank mismatch between encoding and tensor shape: "
+           << getDimRank() << " != " << dimRank;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Convenience Methods.
 //===----------------------------------------------------------------------===//
 
 SparseTensorEncodingAttr
Level mlir::sparse_tensor::getCOOStart(SparseTensorEncodingAttr enc) {
   return lvlRank;
 }
 
 // Helpers to setup a COO type.
 RankedTensorType sparse_tensor::getCOOFromTypeWithOrdering(RankedTensorType rtt,
                                                            AffineMap lvlPerm,
                                                            bool ordered) {
   const SparseTensorType src(rtt);
-  // The dim-rank of the source `RankedTensorType` is used as the lvl-rank
-  // of the result `RankedTensorType`.  This follows from the fact that the
-  // result's encoding has the default higher-ordering (hence the result's
-  // lvl-rank equals its dim-rank).  We don't need to assert that `lvlRank`
-  // agrees with the size of `lvlPerm` because that will be verified by
-  // `STEA::get`.
-  const Level lvlRank = src.getDimRank();
+  // TODO: This assertion is to match the behavior from before we merged
+  // dimOrdering and higherOrdering into dimToLvl.  However, there's no
+  // in-principle reason to require this.  (wrengr has a commit in the
+  // wings to fix this.)
+  assert(src.isPermutation());
+  const Level lvlRank = src.getLvlRank();
   SmallVector<DimLevelType> lvlTypes;
+  lvlTypes.reserve(lvlRank);
 
   // An unordered and non-unique compressed level at beginning.
   // If this is also the last level, then it is unique.
   lvlTypes.push_back(
       *buildLevelType(LevelFormat::Compressed, ordered, lvlRank == 1));
   if (lvlRank > 1) {
     // TODO: it is actually ordered at the level for ordered input.
     // Followed by unordered non-unique n-2 singleton levels.
     std::fill_n(std::back_inserter(lvlTypes), lvlRank - 2,
                 *buildLevelType(LevelFormat::Singleton, ordered, false));
     // Ends by a unique singleton level unless the lvlRank is 1.
     lvlTypes.push_back(*buildLevelType(LevelFormat::Singleton, ordered, true));
   }
 
   // TODO: Maybe pick the bitwidth based on input/output tensors (probably the
   // largest one among them) in the original operation instead of using the
   // default value.
   unsigned posWidth = src.getPosWidth();
   unsigned crdWidth = src.getCrdWidth();
   auto enc = SparseTensorEncodingAttr::get(src.getContext(), lvlTypes, lvlPerm,
-                                           AffineMap(), posWidth, crdWidth);
+                                           posWidth, crdWidth);
   return RankedTensorType::get(src.getDimShape(), src.getElementType(), enc);
 }
 
 RankedTensorType sparse_tensor::getCOOFromType(RankedTensorType src,
                                                bool ordered) {
   return getCOOFromTypeWithOrdering(
       src, AffineMap::getMultiDimIdentityMap(src.getRank(), src.getContext()),
       ordered);
 }
 
 // TODO: Remove this definition once all use-sites have been fixed to
 // properly handle non-permutations.
 Dimension mlir::sparse_tensor::toOrigDim(SparseTensorEncodingAttr enc,
                                          Level l) {
   if (enc) {
-    auto order = enc.getDimOrdering();
-    if (order) {
-      assert(order.isPermutation());
-      return order.getDimPosition(l);
+    if (const auto dimToLvl = enc.getDimToLvl()) {
+      assert(enc.isPermutation());
+      return dimToLvl.getDimPosition(l);
     }
   }
   return l;
 }
 
 // TODO: Remove this definition once all use-sites have been fixed to
 // properly handle non-permutations.
 Level mlir::sparse_tensor::toStoredDim(SparseTensorEncodingAttr enc,
                                        Dimension d) {
   if (enc) {
-    auto order = enc.getDimOrdering();
-    if (order) {
-      assert(order.isPermutation());
+    if (const auto dimToLvl = enc.getDimToLvl()) {
+      assert(enc.isPermutation());
       auto maybePos =
-          order.getResultPosition(getAffineDimExpr(d, enc.getContext()));
+          dimToLvl.getResultPosition(getAffineDimExpr(d, enc.getContext()));
       assert(maybePos.has_value());
       return *maybePos;
     }
   }
   return d;
 }
 
 // TODO: Remove this definition once all use-sites have been fixed to

 static SparseTensorEncodingAttr
 getNormalizedEncodingForSpecifier(SparseTensorEncodingAttr enc) {
   SmallVector<DimLevelType> dlts;
   for (auto dlt : enc.getLvlTypes())
     dlts.push_back(*buildLevelType(*getLevelFormat(dlt), true, true));
 
   return SparseTensorEncodingAttr::get(
       enc.getContext(), dlts,
-      AffineMap(), // dimOrdering (irrelavant to storage speicifer)
-      AffineMap(), // highLvlOrdering (irrelavant to storage specifer)
+      AffineMap(), // dimToLvl (irrelevant to storage specifier)
       // Always use `index` for memSize and lvlSize instead of reusing
       // `getPosWidth` and `getCrdWidth`. It allows us to reuse the same SSA
       // value for different bitwidth, it also avoids casting between index and
       // integer (returned by DimOp)
       0, 0, enc.getDimSlices());
 }
 
 StorageSpecifierType

mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp

for (Level l = 0; l < lvlRank; l++) {
             genToCoordinates(builder, loc, tensor, l, cooStart);
       } else {
         // Dense level, nothing to fetch.
         assert(isDenseDLT(lvlTp));
       }
 
       // FIXME: `toOrigDim` is deprecated.  For now this relies on the
       // 1:1 mapping between levels and dimensions, since nowhere else
-      // in the code supports HigherOrdering yet either.
+      // in the code supports non-permutations yet either.
       Value lvlSz = mlir::linalg::createOrFoldDimOp(builder, loc, tensor,
                                                     toOrigDim(enc, l));
       // Find upper bound in current dimension.
       highs[t][l] = lvlSizes[t][l] = lvlSz;
       if (isSparseSlices[t]) {
         sliceOffsets[t][l] = genSliceOffset(builder, loc, tensors[t], l);
         sliceStrides[t][l] = genSliceStride(builder, loc, tensors[t], l);
       }

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp

for (Level l = 0; l < lvlRank; l++)
       nameOstream << toMLIRString(stt.getLvlType(l)) << "_";
     // Static dim sizes are used in the generated code while dynamic sizes are
     // loaded from the dimSizes buffer. This is the reason for adding the shape
     // to the function name.
     for (const auto sh : stt.getDimShape())
       nameOstream << sh << "_";
     // Permutation information is also used in generating insertion.
     if (!stt.isIdentity())
-      nameOstream << stt.getDimToLvlMap() << "_";
+      nameOstream << stt.getDimToLvl() << "_";
     nameOstream << stt.getElementType() << "_";
     nameOstream << stt.getCrdWidth() << "_" << stt.getPosWidth();
     return nameOstream.str().str();
   }
 
 private:
   TensorType rtp;
 };
matchAndRewrite(tensor::ExtractSliceOp op, OpAdaptor adaptor,
     Location loc = op.getLoc();
     MLIRContext *ctx = op.getContext();
     auto srcEnc = getSparseTensorEncoding(op.getSourceType());
     auto dstEnc = getSparseTensorEncoding(op.getResult().getType());
     // TODO: We should check these in ExtractSliceOp::verify.
     if (!srcEnc || !dstEnc || !dstEnc.isSlice())
       return failure();
     assert(srcEnc.getLvlTypes() == dstEnc.getLvlTypes());
-    assert(srcEnc.getDimOrdering() == dstEnc.getDimOrdering());
-    assert(srcEnc.getHigherOrdering() == dstEnc.getHigherOrdering());
+    assert(srcEnc.getDimToLvl() == dstEnc.getDimToLvl());
     assert(srcEnc.getPosWidth() == dstEnc.getPosWidth());
     assert(srcEnc.getCrdWidth() == dstEnc.getCrdWidth());
 
     SmallVector<Value> fields;
     auto desc = getMutDescriptorFromTensorTuple(adaptor.getSource(), fields);
 
     auto newSpec = rewriter.create<StorageSpecifierInitOp>(
         loc, StorageSpecifierType::get(ctx, dstEnc), desc.getSpecifier());
for (auto [idx, offset, size, stride] : llvm::enumerate(
       // requires us to fill the hole when casting a static slice to dynamic
       // slice.
       desc.setSpecifierField(rewriter, loc, StorageSpecifierKind::DimOffset,
                              dim, offsetV);
 
       // FIXME: we need to distinguish level sizes and dimension size for slices
       // here. Maybe we should store slice level sizes in a different array
       // instead of reusing it.
-      assert(srcEnc.hasIdDimOrdering());
+      assert(srcEnc.isIdentity());
       desc.setSpecifierField(rewriter, loc, StorageSpecifierKind::LvlSize, dim,
                              sizeV);
       desc.setSpecifierField(rewriter, loc, StorageSpecifierKind::DimStride,
                              dim, strideV);
     }
 
     // NOTE: we can not generate tuples directly from descriptor here, as the
     // descriptor is holding the original type, yet we want the slice type
Value nse = createFuncCall(rewriter, loc, "getSparseTensorReaderNSE",
                                {indexTp}, {reader}, EmitCInterface::Off)
                     .getResult(0);
     // Construct allocation for each field.
     SmallVector<Value> fields;
     createAllocFields(rewriter, loc, dstTp, dynSizes, /*enableInit=*/false,
                       fields, nse);
     MutSparseTensorDescriptor desc(dstTp, fields);
 
-    // Construct the `dim2lvl` buffer for handing off to the runtime library.
+    // Construct the `dimToLvl` buffer for handing off to the runtime library.
     // FIXME: This code is (mostly) copied from the SparseTensorConversion.cpp
     // handling of `NewOp`, and only handles permutations.  Fixing this
     // requires waiting for wrengr to finish redoing the CL that handles
     // all dim<->lvl stuff more robustly.
-    SmallVector<Value> dim2lvlValues(dimRank);
+    SmallVector<Value> dimToLvlValues(dimRank);
     if (!dstTp.isIdentity()) {
-      const auto dimOrder = dstTp.getDimToLvlMap();
-      assert(dimOrder.isPermutation() && "Got non-permutation");
+      const auto dimToLvl = dstTp.getDimToLvl();
+      assert(dimToLvl.isPermutation() && "Got non-permutation");
       for (Level l = 0; l < lvlRank; l++) {
-        const Dimension d = dimOrder.getDimPosition(l);
-        dim2lvlValues[d] = constantIndex(rewriter, loc, l);
+        const Dimension d = dimToLvl.getDimPosition(l);
+        dimToLvlValues[d] = constantIndex(rewriter, loc, l);
       }
     } else {
       // The `SparseTensorType` ctor already ensures `dimRank == lvlRank`
       // when `isIdentity`; so no need to re-assert it here.
       for (Dimension d = 0; d < dimRank; d++)
-        dim2lvlValues[d] = constantIndex(rewriter, loc, d);
+        dimToLvlValues[d] = constantIndex(rewriter, loc, d);
     }
-    Value dim2lvl = allocaBuffer(rewriter, loc, dim2lvlValues);
+    Value dimToLvl = allocaBuffer(rewriter, loc, dimToLvlValues);
 
     // Read the COO tensor data.
     Value xs = desc.getAOSMemRef();
     Value ys = desc.getValMemRef();
 
     const Type boolTp = rewriter.getIntegerType(1);
     const Type elemTp = dstTp.getElementType();
     const Type crdTp = dstTp.getCrdType();
     // FIXME: This function name is weird; should rename to
     // "sparseTensorReaderReadToBuffers".
     SmallString<32> readToBuffersFuncName{"getSparseTensorReaderRead",
                                           overheadTypeFunctionSuffix(crdTp),
                                           primaryTypeFunctionSuffix(elemTp)};
     Value isSorted =
         createFuncCall(rewriter, loc, readToBuffersFuncName, {boolTp},
-                       {reader, dim2lvl, xs, ys}, EmitCInterface::On)
+                       {reader, dimToLvl, xs, ys}, EmitCInterface::On)
             .getResult(0);
 
     // If the destination tensor is a sorted COO, we need to sort the COO tensor
     // data if the input elements aren't sorted yet.
     if (dstTp.isOrderedLvl(lvlRank - 1)) {
       Value kFalse = constantI1(rewriter, loc, false);
       Value notSorted = rewriter.create<arith::CmpIOp>(
           loc, arith::CmpIPredicate::eq, isSorted, kFalse);

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

static Value createOrFoldLvlCall(OpBuilder &builder, Location loc,
   assert(stt.hasEncoding());
   // TODO: The following implementation only handles permutations;
   // we'll need to generalize this to handle arbitrary AffineExpr.
   //
   // There's no need to assert `isPermutation` here: because
   // `getDimPosition` checks that the expr isa `AffineDimExpr`,
   // which is all we care about (for supporting permutations).
   const Dimension dim =
-      stt.isIdentity() ? lvl : stt.getDimToLvlMap().getDimPosition(lvl);
+      stt.isIdentity() ? lvl : stt.getDimToLvl().getDimPosition(lvl);
   if (const auto sz = stt.getStaticDimSize(dim))
     return constantIndex(builder, loc, *sz);
   // If we cannot statically compute the size from the shape, then we
   // must dynamically query it.  (In principle we could also dynamically
   // compute it, but since we already did so to construct the `tensor`
   // in the first place, we might as well query rather than recompute.)
   return genLvlSizeCall(builder, loc, tensor, lvl);
 }
bool isInitialized() const {
     return true;
   }
 
   /// Gets the dimension-to-level mapping.
   //
   // TODO: This is only ever used for passing into `genAddEltCall`;
   // is there a better way to encapsulate that pattern (both to avoid
   // this one-off getter, and to avoid potential mixups)?
-  Value getDim2LvlMap() const {
-    assert(isInitialized() && "Must initialize before getDim2LvlMap");
-    return params[kParamDim2Lvl];
+  Value getDimToLvl() const {
+    assert(isInitialized() && "Must initialize before getDimToLvl");
+    return params[kParamDimToLvl];
   }
 
   /// Generates a function call, with the current static parameters
   /// and the given dynamic arguments.
   Value genNewCall(Action action, Value ptr = Value()) {
     assert(isInitialized() && "Must initialize before genNewCall");
     StringRef name = "newSparseTensor";
     params[kParamAction] = constantAction(builder, loc, action);
     params[kParamPtr] = ptr ? ptr : builder.create<LLVM::NullOp>(loc, pTp);
     return createFuncCall(builder, loc, name, pTp, params, EmitCInterface::On)
         .getResult(0);
   }
 
 private:
   static constexpr unsigned kNumStaticParams = 8;
   static constexpr unsigned kNumDynamicParams = 2;
   static constexpr unsigned kNumParams = kNumStaticParams + kNumDynamicParams;
   static constexpr unsigned kParamDimSizes = 0;
   static constexpr unsigned kParamLvlSizes = 1;
   static constexpr unsigned kParamLvlTypes = 2;
-  static constexpr unsigned kParamLvl2Dim = 3;
-  static constexpr unsigned kParamDim2Lvl = 4;
+  static constexpr unsigned kParamLvlToDim = 3;
+  static constexpr unsigned kParamDimToLvl = 4;
   static constexpr unsigned kParamPosTp = 5;
   static constexpr unsigned kParamCrdTp = 6;
   static constexpr unsigned kParamValTp = 7;
   static constexpr unsigned kParamAction = 8;
   static constexpr unsigned kParamPtr = 9;
 
   OpBuilder &builder;
   Location loc;
NewCallParams &NewCallParams::genBuffers(SparseTensorType stt,
   // Sparsity annotations.
   params[kParamLvlTypes] = genLvlTypesBuffer(builder, loc, stt);
   // Dimension-sizes array of the enveloping tensor.  Useful for either
   // verification of external data, or for construction of internal data.
   assert(dimSizes.size() == static_cast<size_t>(dimRank) &&
          "Dimension-rank mismatch");
   params[kParamDimSizes] = allocaBuffer(builder, loc, dimSizes);
   // The level-sizes array must be passed as well, since for arbitrary
-  // dim2lvl mappings it cannot be trivially reconstructed at runtime.
+  // dimToLvl mappings it cannot be trivially reconstructed at runtime.
   // For now however, since we're still assuming permutations, we will
-  // initialize this parameter alongside the `dim2lvl` and `lvl2dim`
+  // initialize this parameter alongside the `dimToLvl` and `lvlToDim`
   // parameters below.  We preinitialize `lvlSizes` for code symmetry.
   SmallVector<Value> lvlSizes(lvlRank);
   // The dimension-to-level mapping and its inverse.  We must preinitialize
-  // `dim2lvl` so that the true branch below can perform random-access
-  // `operator[]` assignment.  We preinitialize `lvl2dim` for code symmetry.
-  SmallVector<Value> dim2lvl(dimRank);
-  SmallVector<Value> lvl2dim(lvlRank);
+  // `dimToLvl` so that the true branch below can perform random-access
+  // `operator[]` assignment.  We preinitialize `lvlToDim` for code symmetry.
+  SmallVector<Value> dimToLvl(dimRank);
+  SmallVector<Value> lvlToDim(lvlRank);
   if (!stt.isIdentity()) {
-    const auto dimOrder = stt.getDimToLvlMap();
-    assert(dimOrder.isPermutation());
+    const auto dimToLvlMap = stt.getDimToLvl();
+    assert(dimToLvlMap.isPermutation());
     for (Level l = 0; l < lvlRank; l++) {
       // The `d`th source variable occurs in the `l`th result position.
-      const Dimension d = dimOrder.getDimPosition(l);
-      dim2lvl[d] = constantIndex(builder, loc, l);
-      lvl2dim[l] = constantIndex(builder, loc, d);
+      const Dimension d = dimToLvlMap.getDimPosition(l);
+      dimToLvl[d] = constantIndex(builder, loc, l);
+      lvlToDim[l] = constantIndex(builder, loc, d);
       lvlSizes[l] = dimSizes[d];
     }
   } else {
     // The `SparseTensorType` ctor already ensures `dimRank == lvlRank`
     // when `isIdentity`; so no need to re-assert it here.
     for (Level l = 0; l < lvlRank; l++) {
-      dim2lvl[l] = lvl2dim[l] = constantIndex(builder, loc, l);
+      dimToLvl[l] = lvlToDim[l] = constantIndex(builder, loc, l);
       lvlSizes[l] = dimSizes[l];
     }
   }
   params[kParamLvlSizes] = allocaBuffer(builder, loc, lvlSizes);
-  params[kParamLvl2Dim] = allocaBuffer(builder, loc, lvl2dim);
-  params[kParamDim2Lvl] = stt.isIdentity()
-                              ? params[kParamLvl2Dim]
-                              : allocaBuffer(builder, loc, dim2lvl);
+  params[kParamLvlToDim] = allocaBuffer(builder, loc, lvlToDim);
+  params[kParamDimToLvl] = stt.isIdentity()
+                               ? params[kParamLvlToDim]
+                               : allocaBuffer(builder, loc, dimToLvl);
   // Secondary and primary types encoding.
   setTemplateTypes(stt);
   // Finally, make note that initialization is complete.
   assert(isInitialized() && "Initialization failed");
   // And return `this` for method chaining.
   return *this;
 }
 

 
 /// Generates a call that adds one element to a coordinate scheme.
 /// In particular, this generates code like the following:
 ///   val = a[i1,..,ik];
 ///   if val != 0
 ///     t->add(&val, [i1,..,ik], [p1,..,pk]);
 static void genAddEltCall(OpBuilder &builder, Location loc, Type eltType,
                           Value lvlCOO, Value valPtr, Value dimCoords,
-                          Value dim2lvl) {
+                          Value dimToLvl) {
   SmallString<9> name{"addElt", primaryTypeFunctionSuffix(eltType)};
-  SmallVector<Value, 4> params{lvlCOO, valPtr, dimCoords, dim2lvl};
+  SmallVector<Value, 4> params{lvlCOO, valPtr, dimCoords, dimToLvl};
   Type pTp = getOpaquePointerType(builder);
   createFuncCall(builder, loc, name, pTp, params, EmitCInterface::On);
 }
 
 /// Generates a call to `iter->getNext()`.  If there is a next element,
 /// then it is copied into the out-parameters `coords` and `elemPtr`,
 /// and the return value is true.  If there isn't a next element, then
 /// the return value is false.
if (!srcTp.hasEncoding() || !dstTp.hasEncoding())
     return failure();
   Type elemTp = srcTp.getElementType();
   assert(elemTp == dstTp.getElementType() &&
          "reshape should not change element type");
   // Start an iterator over the source tensor (in coordinate order).
   SmallVector<Value> srcDimSizes =
       getDimSizes(rewriter, loc, srcTp, adaptor.getSrc());
   NewCallParams params(rewriter, loc);
-  Value iter = params.genBuffers(srcTp.withoutOrdering(), srcDimSizes)
+  Value iter = params.genBuffers(srcTp.withoutDimToLvl(), srcDimSizes)
                    .genNewCall(Action::kToIterator, adaptor.getSrc());
   // Start a new COO for the destination tensor.
   SmallVector<Value> dstDimSizes;
   if (dstTp.hasStaticDimShape())
     // Static "shapes" are in fact "sizes".
     fillDimShape(rewriter, loc, dstTp, dstDimSizes);
   else
     genReshapeDstShape(rewriter, loc, dstDimSizes, srcDimSizes,
                        dstTp.getDimShape(), op.getReassociationIndices());
   const Value coo =
       params.genBuffers(dstTp, dstDimSizes).genNewCall(Action::kEmptyCOO);
-  const Value dstPerm = params.getDim2LvlMap();
+  const Value dstDimToLvl = params.getDimToLvl();
   // Construct a while loop over the iterator.
   const Type iTp = rewriter.getIndexType();
   const Value srcDimCoords = genAlloca(rewriter, loc, srcTp.getDimRank(), iTp);
   const Value dstDimCoords = genAlloca(rewriter, loc, dstTp.getDimRank(), iTp);
   const Value elemPtr = genAllocaScalar(rewriter, loc, elemTp);
   const SmallVector<Value> noArgs;
   const SmallVector<Type> noTypes;
   auto whileOp = rewriter.create<scf::WhileOp>(loc, noTypes, noArgs);
   Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, noTypes);
   rewriter.setInsertionPointToEnd(before);
   Value cond = genGetNextCall(rewriter, loc, iter, srcDimCoords, elemPtr);
   rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments());
   // Translate coordinates from source to target and insert. Note that we do
   // not need to store the value in elemPtr, as the value is still there.
   Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, noTypes);
   rewriter.setInsertionPointToStart(after);
   // We probably don't need these assertions, but better safe than sorry.
   assert(srcTp.getDimRank() == srcDimSizes.size());
   assert(dstTp.getDimRank() == dstDimSizes.size());
   reshapeCoords(loc, rewriter, op.getReassociationIndices(), srcDimSizes,
                 srcDimCoords, dstDimSizes, dstDimCoords);
-  genAddEltCall(rewriter, loc, elemTp, coo, elemPtr, dstDimCoords, dstPerm);
+  genAddEltCall(rewriter, loc, elemTp, coo, elemPtr, dstDimCoords, dstDimToLvl);
   rewriter.create<scf::YieldOp>(loc);
   // Final call to construct sparse tensor storage and free temporary resources.
   rewriter.setInsertionPointAfter(whileOp);
   Value dst = params.genNewCall(Action::kFromCOO, coo);
   genDelCOOCall(rewriter, loc, elemTp, coo);
   genDelIteratorCall(rewriter, loc, elemTp, iter);
   rewriter.replaceOp(op, dst);
   return success();
static void genSparseCOOIterationLoop(
     SparseTensorType stt,
     function_ref<void(OpBuilder &, Location, Value, Value)> bodyBuilder) {
   assert(stt.hasEncoding() &&
          "Generating Sparse Tensor COO Loop on a Dense Tensor!");
   const Dimension dimRank = stt.getDimRank();
   const Type elemTp = stt.getElementType();
 
   // Start an iterator over the tensor (in coordinate order).
-  const auto noPerm = stt.withoutOrdering();
+  const auto noPerm = stt.withoutDimToLvl();
   SmallVector<Value> dimSizes = getDimSizes(rewriter, loc, noPerm, t);
   Value iter = NewCallParams(rewriter, loc)
                    .genBuffers(noPerm, dimSizes)
                    .genNewCall(Action::kToIterator, t);
 
   // Construct a while loop over the iterator.
   const Type iTp = rewriter.getIndexType();
   Value srcDimCoords = genAlloca(rewriter, loc, dimRank, iTp);
matchAndRewrite(NewOp op, OpAdaptor adaptor,
     if (!stt.hasEncoding())
       return failure();
     const Dimension dimRank = stt.getDimRank();
     const Level lvlRank = stt.getLvlRank();
     // Construct the dimShape.
     SmallVector<Value> dimShapeValues = getDimShape(rewriter, loc, stt);
     Value dimShapeBuffer = allocaBuffer(rewriter, loc, dimShapeValues);
     // Allocate `SparseTensorReader` and perform all initial setup that
-    // does not depend on lvlSizes (nor dim2lvl, lvl2dim, etc).
+    // does not depend on lvlSizes (nor dimToLvl, lvlToDim, etc).
     Type opaqueTp = getOpaquePointerType(rewriter);
     Value valTp =
         constantPrimaryTypeEncoding(rewriter, loc, stt.getElementType());
     Value reader =
         createFuncCall(rewriter, loc, "createCheckedSparseTensorReader",
                        opaqueTp,
                        {adaptor.getOperands()[0], dimShapeBuffer, valTp},
                        EmitCInterface::On)
             .getResult(0);
     // Construct the lvlSizes.  If the dimShape is static, then it's
     // identical to dimSizes: so we can compute lvlSizes entirely at
     // compile-time.  If dimShape is dynamic, then we'll need to generate
     // code for computing lvlSizes from the `reader`'s actual dimSizes.
     //
-    // TODO: For now we're still assuming `dim2lvl` is a permutation.
+    // TODO: For now we're still assuming `dimToLvl` is a permutation.
     // But since we're computing lvlSizes here (rather than in the runtime),
     // we can easily generalize that simply by adjusting this code.
     //
     // FIXME: reduce redundancy vs `NewCallParams::genBuffers`.
     Value dimSizesBuffer;
     if (stt.hasDynamicDimShape()) {
       Type indexTp = rewriter.getIndexType();
       auto memTp = MemRefType::get({ShapedType::kDynamic}, indexTp);
       dimSizesBuffer =
           createFuncCall(rewriter, loc, "getSparseTensorReaderDimSizes", memTp,
                          reader, EmitCInterface::On)
               .getResult(0);
     }
     Value lvlSizesBuffer;
-    Value lvl2dimBuffer;
-    Value dim2lvlBuffer;
+    Value lvlToDimBuffer;
+    Value dimToLvlBuffer;
     if (!stt.isIdentity()) {
-      const auto dimOrder = stt.getDimToLvlMap();
-      assert(dimOrder.isPermutation() && "Got non-permutation");
-      // We preinitialize `dim2lvlValues` since we need random-access writing.
+      const auto dimToLvl = stt.getDimToLvl();
+      assert(dimToLvl.isPermutation() && "Got non-permutation");
+      // We preinitialize `dimToLvlValues` since we need random-access writing.
       // And we preinitialize the others for stylistic consistency.
       SmallVector<Value> lvlSizeValues(lvlRank);
-      SmallVector<Value> lvl2dimValues(lvlRank);
-      SmallVector<Value> dim2lvlValues(dimRank);
+      SmallVector<Value> lvlToDimValues(lvlRank);
+      SmallVector<Value> dimToLvlValues(dimRank);
       for (Level l = 0; l < lvlRank; l++) {
         // The `d`th source variable occurs in the `l`th result position.
-        Dimension d = dimOrder.getDimPosition(l);
+        Dimension d = dimToLvl.getDimPosition(l);
         Value lvl = constantIndex(rewriter, loc, l);
         Value dim = constantIndex(rewriter, loc, d);
-        dim2lvlValues[d] = lvl;
-        lvl2dimValues[l] = dim;
+        dimToLvlValues[d] = lvl;
+        lvlToDimValues[l] = dim;
         lvlSizeValues[l] =
             stt.isDynamicDim(d)
                 ? rewriter.create<memref::LoadOp>(loc, dimSizesBuffer, dim)
                 : dimShapeValues[d];
       }
       lvlSizesBuffer = allocaBuffer(rewriter, loc, lvlSizeValues);
-      lvl2dimBuffer = allocaBuffer(rewriter, loc, lvl2dimValues);
-      dim2lvlBuffer = allocaBuffer(rewriter, loc, dim2lvlValues);
+      lvlToDimBuffer = allocaBuffer(rewriter, loc, lvlToDimValues);
+      dimToLvlBuffer = allocaBuffer(rewriter, loc, dimToLvlValues);
     } else {
       // The `SparseTensorType` ctor already ensures `dimRank == lvlRank`
       // when `isIdentity`; so no need to re-assert it here.
       SmallVector<Value> iotaValues;
       iotaValues.reserve(lvlRank);
       for (Level l = 0; l < lvlRank; l++)
         iotaValues.push_back(constantIndex(rewriter, loc, l));
       lvlSizesBuffer = dimSizesBuffer ? dimSizesBuffer : dimShapeBuffer;
-      dim2lvlBuffer = lvl2dimBuffer = allocaBuffer(rewriter, loc, iotaValues);
+      dimToLvlBuffer = lvlToDimBuffer = allocaBuffer(rewriter, loc, iotaValues);
     }
     // Use the `reader` to parse the file.
     SmallVector<Value, 8> params{
         reader,
         lvlSizesBuffer,
         genLvlTypesBuffer(rewriter, loc, stt),
-        lvl2dimBuffer,
-        dim2lvlBuffer,
+        lvlToDimBuffer,
+        dimToLvlBuffer,
         constantPosTypeEncoding(rewriter, loc, stt.getEncoding()),
         constantCrdTypeEncoding(rewriter, loc, stt.getEncoding()),
         valTp};
     Value tensor = createFuncCall(rewriter, loc, "newSparseTensorFromReader",
                                   opaqueTp, params, EmitCInterface::On)
                        .getResult(0);
     // Free the memory for `reader`.
     createFuncCall(rewriter, loc, "delSparseTensorReader", {}, {reader},
if (srcTp.hasEncoding() && dstTp.hasEncoding()) {
       if (useDirectConversion) {
         rewriter.replaceOp(
             op, params.genBuffers(srcTp.withEncoding(dstEnc), dimSizes)
                     .genNewCall(Action::kSparseToSparse, src));
       } else { // use via-COO conversion.
         // Set up encoding with right mix of src and dst so that the two
         // method calls can share most parameters, while still providing
         // the correct sparsity information to either of them.
-        const auto mixedEnc = SparseTensorEncodingAttr::get(
-            op->getContext(), dstEnc.getLvlTypes(), dstEnc.getDimOrdering(),
-            dstEnc.getHigherOrdering(), srcEnc.getPosWidth(),
-            srcEnc.getCrdWidth());
+        const auto mixedEnc =
+            dstEnc.withBitWidths(srcEnc.getPosWidth(), srcEnc.getCrdWidth());
         // TODO: This is the only place where `kToCOO` (or `kToIterator`)
         // is called with a non-identity permutation.  Is there any clean
         // way to push the permutation over to the `kFromCOO` side instead?
         Value coo = params.genBuffers(srcTp.withEncoding(mixedEnc), dimSizes)
                         .genNewCall(Action::kToCOO, src);
         Value dst = params.setTemplateTypes(srcTp.withEncoding(dstEnc))
                         .genNewCall(Action::kFromCOO, coo);
         genDelCOOCall(rewriter, loc, elemTp, coo);
if (srcTp.hasEncoding() && !dstTp.hasEncoding()) {
       //   delete iter;
       //
       // Fabricate a no-permutation encoding for NewCallParams
       // The position/coordinate types must be those of `src`.
       // The dimLevelTypes aren't actually used by Action::kToIterator.
       const auto dstEnc = SparseTensorEncodingAttr::get(
           op->getContext(),
           SmallVector<DimLevelType>(dimRank, DimLevelType::Dense), AffineMap(),
-          AffineMap(), srcEnc.getPosWidth(), srcEnc.getCrdWidth());
+          srcEnc.getPosWidth(), srcEnc.getCrdWidth());
       SmallVector<Value> dimSizes = getDimSizes(rewriter, loc, srcTp, src);
       Value iter = NewCallParams(rewriter, loc)
                        .genBuffers(dstTp.withEncoding(dstEnc), dimSizes)
                        .genNewCall(Action::kToIterator, src);
       const Type iTp = rewriter.getIndexType();
       Value dimCoords = genAlloca(rewriter, loc, dimRank, iTp);
       Value elemPtr = genAllocaScalar(rewriter, loc, elemTp);
       Block *insertionBlock = rewriter.getInsertionBlock();
matchAndRewrite(ConvertOp op, OpAdaptor adaptor,
     // loop is generated by genAddElt().
     SmallVector<Value> dimSizes;
     sizesFromSrc(rewriter, dimSizes, loc, src);
     NewCallParams params(rewriter, loc);
     Value coo =
         params.genBuffers(dstTp, dimSizes).genNewCall(Action::kEmptyCOO);
     const Type iTp = rewriter.getIndexType();
     Value dimCoords = genAlloca(rewriter, loc, dimRank, iTp);
-    Value perm = params.getDim2LvlMap();
+    Value dimToLvl = params.getDimToLvl();
     Value elemPtr = genAllocaScalar(rewriter, loc, elemTp);
     genDenseTensorOrSparseConstantIterLoop(
         rewriter, loc, src, dimRank,
         [&](OpBuilder &builder, Location loc, Value val, ValueRange dcvs) {
           assert(dcvs.size() == static_cast<size_t>(dimRank));
           storeAll(builder, loc, dimCoords, dcvs);
           builder.create<memref::StoreOp>(loc, val, elemPtr);
-          genAddEltCall(builder, loc, elemTp, coo, elemPtr, dimCoords, perm);
+          genAddEltCall(builder, loc, elemTp, coo, elemPtr, dimCoords,
+                        dimToLvl);
         });
     // Final call to construct sparse tensor storage.
     Value dst = params.genNewCall(Action::kFromCOO, coo);
     genDelCOOCall(rewriter, loc, elemTp, coo);
     rewriter.replaceOp(op, dst);
     return success();
   }
 
matchAndRewrite(ConcatenateOp op, OpAdaptor adaptor,
     Location loc = op.getLoc();
     const auto dstTp = getSparseTensorType(op);
     const auto dstEnc = dstTp.getEncoding();
     const Type elemTp = dstTp.getElementType();
     const Dimension concatDim = op.getDimension();
     const Dimension dimRank = dstTp.getDimRank();
 
     Value dst;     // destination tensor
-    Value dstPerm; // destination tensor permutation (if sparse out)
+    Value dstDimToLvl; // destination tensor permutation (if sparse out)
     // A pointer to the value being inserted (if dense => sparse)
     Value elemPtr;
     // Memory that holds the dim-coords for destination tensor (if sparse out)
     Value dstDimCoords;
     // The offset applied to the dimension to be concated (starting from 0)
     Value offset = constantIndex(rewriter, loc, 0);
 
     SmallVector<Value> dimSizes;
if (dstTp.hasEncoding()) {
                             {dst});
         // Pass the `dstDimCoords` buffer for `reshapeValuesToLevels`
         // to reuse for storing level-sizes (yes, "level-sizes").
         // This is safe to do because `dstTp` is a dense-tensor type,
         // and therefore lvlRank == dimRank.
         dst = reshapeValuesToLevels(rewriter, loc, dstEnc, dimSizes, dst,
                                     dstDimCoords);
       } else {
-        dstPerm = params.getDim2LvlMap();
+        dstDimToLvl = params.getDimToLvl();
         elemPtr = genAllocaScalar(rewriter, loc, elemTp);
       }
     } else {
       // TODO: Dense buffers should be allocated/deallocated via the callback
       // in BufferizationOptions.
       dst = allocDenseTensor(rewriter, loc, dstTp, dimSizes);
     }
     const Level lvlRank = dstTp.getLvlRank();
for (const auto &it : llvm::zip(op.getInputs(), adaptor.getInputs())) {
             [&](OpBuilder &builder, Location loc, Value dimCoords,
                 Value elemPtr) -> void {
               const auto dcvs =
                   loadAll(builder, loc, dimRank, dimCoords, concatDim, offset);
               if (dstTp.hasEncoding() && !allDense) {
                 // Case: sparse => sparse, except for annotated all dense.
                 storeAll(builder, loc, dstDimCoords, dcvs);
                 genAddEltCall(builder, loc, elemTp, dst, elemPtr, dstDimCoords,
-                              dstPerm);
+                              dstDimToLvl);
               } else {
                 // Case: sparse => dense, or annotated all dense.
                 const auto lcvs = allDense ? dcvs2lcvs(dcvs) : dcvs;
                 insertScalarIntoDenseTensor(builder, loc, elemPtr, dst, lcvs);
               }
             });
       } else {
         genDenseTensorIterationLoop(
             rewriter, loc, adaptedOp, srcTp,
             [&](OpBuilder &builder, Location loc, ValueRange dcvs) -> void {
               if (dstTp.hasEncoding() && !allDense) {
                 // Case: dense => sparse, except for annotated all dense.
                 assert(dcvs.size() == static_cast<size_t>(dimRank));
                 storeAll(builder, loc, dstDimCoords, dcvs, concatDim, offset);
                 Value val = genValueForDense(builder, loc, adaptedOp, dcvs);
                 builder.create<memref::StoreOp>(loc, val, elemPtr);
                 genAddEltCall(builder, loc, elemTp, dst, elemPtr, dstDimCoords,
-                              dstPerm);
+                              dstDimToLvl);
               } else {
                 // Case: dense => dense, or annotated all dense.
                 Value val = genValueForDense(builder, loc, adaptedOp, dcvs);
                 // Despite the name, this isn't actually level-cvs until
                 // after the `dcvs2lcvs` call.
                 SmallVector<Value> lcvs(dcvs);
                 // Apply offset.
                 lcvs[concatDim] =
public:
   matchAndRewrite(OutOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     const Location loc = op->getLoc();
     const auto srcTp = getSparseTensorType(op.getTensor());
     // Convert to default permuted COO.
     Value src = adaptor.getOperands()[0];
     SmallVector<Value> dimSizes = getDimSizes(rewriter, loc, srcTp, src);
     Value coo = NewCallParams(rewriter, loc)
-                    .genBuffers(srcTp.withoutOrdering(), dimSizes)
+                    .genBuffers(srcTp.withoutDimToLvl(), dimSizes)
                     .genNewCall(Action::kToCOO, src);
     // Then output the tensor to external file with coordinates in the
     // externally visible lexicographic coordinate order.  A sort is
     // required if the source was not in that order yet (note that the
     // sort can be dropped altogether if external format does not care
     // about the order at all, but here we assume it does).
     const Value sort = constantI1(rewriter, loc, !srcTp.isIdentity());
     SmallVector<Value, 3> outParams{coo, adaptor.getOperands()[1], sort};

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

for (const auto &d : enumerate(stp.getShape())) {
     else
       dim = constantIndex(builder, loc, d.value());
     sizes.push_back(dim);
   }
 }
 
 // TODO: The dim level property of the COO type relies on input tensors, the
 // shape relies on the output tensor
-static RankedTensorType
-getUnorderedCOOFromTypeWithOrdering(RankedTensorType src, AffineMap ordering) {
-  return getCOOFromTypeWithOrdering(src, ordering, false);
+static RankedTensorType getCOOType(const SparseTensorType &stt, bool ordered) {
+  return getCOOFromTypeWithOrdering(stt, stt.getDimToLvl(), ordered);
 }
 
-static RankedTensorType getUnorderedCOOFromType(RankedTensorType src) {
-  return getCOOFromType(src, false);
+static RankedTensorType getBufferType(const SparseTensorType &stt,
+                                      bool needTmpCOO) {
+  return needTmpCOO ? getCOOType(stt, /*ordered=*/false)
+                    : stt.getRankedTensorType();
 }
 
 /// Collects the dynamic dimension sizes for `tp` with the assumption that
 /// `sizes` are the dimension sizes for the type. Stores the dynamic dimension
 /// sizes to dynSizes.
 static void getDynamicSizes(RankedTensorType tp,
                             const SmallVectorImpl<Value> &sizes,
                             SmallVectorImpl<Value> &dynSizes) {
LogicalResult matchAndRewrite(tensor::ReshapeOp op,
     sizesForTensor(rewriter, srcSizes, loc, srcTp, srcTensor);
     SmallVector<Value> dstSizes;
     for (Dimension d : dstTp.getDimShape())
       dstSizes.push_back(constantIndex(rewriter, loc, d));
 
     Value nnz = rewriter.create<NumberOfEntriesOp>(loc, srcTensor);
     // Only need an unordered COO buffer if input and output are not sorted
     // in the same way.
-    Type bufferTp =
-        srcTp.isAllOrdered() && srcTp.isIdentity() && dstTp.isIdentity()
-            ? dstTp.getRankedTensorType()
-            : getUnorderedCOOFromType(dstTp);
+    Type bufferTp = getBufferType(
+        dstTp.withoutDimToLvl(),
+        !srcTp.isAllOrdered() || !srcTp.isIdentity() || !dstTp.isIdentity());
     SmallVector<Value> dynSizes;
     Value buffer = rewriter
                        .create<AllocTensorOp>(loc, bufferTp, dynSizes, Value(),
                                               nnz, Attribute())
                        .getResult();
 
     // Convert src coordinates to dst coordinates by first collapsing it to 1D
     // and then expand it to the match the rank of the destination tensor.
if (dstTp.hasStaticDimShape()) {
       for (auto [idx, shape] : llvm::enumerate(dstShape)) {
         if (shape == ShapedType::kDynamic)
           dstDynSizes.push_back(dstSizes[idx]);
       }
     }
     Value nnz = rewriter.create<NumberOfEntriesOp>(loc, srcTensor);
     // Only need a unordered COO buffer if input and output are not sorted
     // in the same way.
-    Type bufferTp =
-        srcTp.isAllOrdered() && srcTp.isIdentity() && dstTp.isIdentity()
-            ? dstTp.getRankedTensorType()
-            : getUnorderedCOOFromType(dstTp);
+    Type bufferTp = getBufferType(
+        dstTp.withoutDimToLvl(),
+        !srcTp.isAllOrdered() || !srcTp.isIdentity() || !dstTp.isIdentity());
 
     Value buffer =
         rewriter
             .create<AllocTensorOp>(loc, bufferTp, dstDynSizes, Value(),
                                    /*sizeHint=*/nnz, Attribute())
             .getResult();
 
     // Implement the sparse2sparse reshape as follows:
LogicalResult matchAndRewrite(ConcatenateOp op,
     // thus not easily extracted.
     auto encDst = dstTp.getEncoding();
     Value dst; // Destination tensor for inserting source tensor values.
     bool needTmpCOO = true;
     const bool allDense = dstTp.hasEncoding() && dstTp.isAllDense();
     Value annotatedDenseDst;
     if (dstTp.hasEncoding()) {
       bool allOrdered = false;
-      // When concatenating on dimension 0, and all inputs are sorted and have
-      // an identity dimOrdering, the concatenate will generate coords in
-      // lexOrder thus no need for the tmp COO buffer.
+      // When concatenating on dimension 0, and all inputs are sorted
+      // and have an identity dimToLvl, the concatenate will generate
+      // coords in lexOrder thus no need for the tmp COO buffer.
       // TODO: When conDim != 0, as long as conDim is the first dimension
       // in all input/output buffers, and all input/output buffers have the same
-      // dimOrdering, the tmp COO buffer is still unnecessary (e.g, concatenate
+      // dimToLvl, the tmp COO buffer is still unnecessary (e.g, concatenate
       // CSC matrices along column).
       if (!allDense && conDim == 0 && dstTp.isIdentity()) {
         for (auto i : op.getInputs()) {
           const auto stt = getSparseTensorType(i);
           allOrdered = stt.isAllOrdered() && stt.isIdentity();
           if (!allOrdered)
             break;
         }
       }
 
       needTmpCOO = !allDense && !allOrdered;
-      const RankedTensorType tp = needTmpCOO ? getUnorderedCOOFromType(dstTp)
-                                             : dstTp.getRankedTensorType();
+      const RankedTensorType tp =
+          getBufferType(dstTp.withoutDimToLvl(), needTmpCOO);
       encDst = needTmpCOO ? getSparseTensorEncoding(tp) : encDst;
       SmallVector<Value> dynSizes;
       getDynamicSizes(dstTp, sizes, dynSizes);
       dst = rewriter.create<AllocTensorOp>(loc, tp, dynSizes).getResult();
       if (allDense) {
         // Create a view of the values buffer to match the unannotated dense
         // tensor.
         Value valuesBuffer = genToValues(rewriter, loc, dst);
LogicalResult dense2SparseRewrite(ConvertOp op,
     }
 
     const auto encDst = dstTp.getEncoding();
     // We don't need a temporary COO tensor if the destination has an identity
     // ordering. Otherwise, we use the destination ordering for the temporary
     // COO tensor.
     // TODO: enhance foreachOp to take ordering to remove the need of a
     // temporary COO tensor here.
-    const RankedTensorType bufferTp = dstTp.isIdentity() || fromSparseConst
-                                          ? dstTp.getRankedTensorType()
-                                          : getUnorderedCOOFromTypeWithOrdering(
-                                                dstTp, dstTp.getDimToLvlMap());
+    const RankedTensorType bufferTp =
+        getBufferType(dstTp, !dstTp.isIdentity() && !fromSparseConst);
     // Only imposes foreach order on dense constant (which will be statically
     // sorted by the sparse compiler), otherwise the rotated loop sequence
     // results to bad cache locality.
-    AffineMapAttr foreachOrder = nullptr;
-    if (encDst.getDimOrdering() && fromSparseConst)
-      foreachOrder = AffineMapAttr::get(encDst.getDimOrdering());
+    const AffineMapAttr foreachOrder =
+        (!dstTp.isIdentity() && fromSparseConst)
+            ? AffineMapAttr::get(dstTp.getExpandedDimToLvl())
+            : nullptr;
+    // TODO: This assertion is to match the behavior from before we merged
+    // dimOrdering and higherOrdering into dimToLvl.  Although the above
+    // can construct `foreachOrder` for non-permutations, it's not clear
+    // that the `foreachOp` below actually supports non-permutations.
+    assert(!foreachOrder || dstTp.isPermutation());
 
     auto buffer =
         rewriter.create<AllocTensorOp>(loc, bufferTp, dynSizes).getResult();
     auto foreachOp = rewriter.create<ForeachOp>(
         loc, src, buffer, foreachOrder,
         [&](OpBuilder &builder, Location loc, ValueRange dcvs, Value v,
             ValueRange reduc) {
           Value input = reduc.front();
LogicalResult sparse2SparseRewrite(ConvertOp op,
     SmallVector<Value> srcSizes;
     sizesForTensor(rewriter, srcSizes, loc, srcRTT, src);
     Value tmpCoo = Value();
     Value nnz = rewriter.create<NumberOfEntriesOp>(loc, src);
     // We need a tmp COO buffer if and only if
     // 1. the src tensor is not a COO and
     // 2. the src tensor is not ordered in the same way as the target
     // tensor (e.g., src tensor is not ordered or src tensor haves a different
-    // dimOrdering).
+    // dimToLvl).
     if (const SparseTensorType srcTp(srcRTT);
-        !(srcTp.isAllOrdered() && srcTp.hasSameDimToLvlMap(dstTp))) {
+        !(srcTp.isAllOrdered() && srcTp.hasSameDimToLvl(dstTp))) {
       // Construct a COO tensor from the src tensor.
       // TODO: there may be cases for which more efficiently without
       // going through an intermediate COO, such as cases that only change
       // the overhead types.
       SmallVector<Value> dynSrcSizes;
       getDynamicSizes(srcRTT, srcSizes, dynSrcSizes);
-      srcRTT =
-          getUnorderedCOOFromTypeWithOrdering(srcRTT, dstTp.getDimToLvlMap());
+      srcRTT = getCOOType(srcTp.withDimToLvl(dstTp), /*ordered=*/false);
       // Ensure that mutating `srcRTT` didn't invalidate `dimRank`.
       assert(static_cast<Dimension>(srcRTT.getRank()) == dimRank);
       tmpCoo = rewriter
                    .create<AllocTensorOp>(loc, srcRTT, dynSrcSizes, Value(),
                                           /*sizeHint=*/nnz, Attribute())
                    .getResult();
       auto foreachOp = rewriter.create<ForeachOp>(
           loc, src, tmpCoo,
LogicalResult sparse2SparseRewrite(ConvertOp op,
     // the guarantee from the sparse tensor encoding).
     if (!srcTp.isAllOrdered()) {
       // Retrieve the values-array.
       Value y = genToValues(rewriter, loc, src);
       const auto encSrc = srcTp.getEncoding();
       // Sort the COO tensor so that its elements are ordered via increasing
       // coordinates for the storage ordering of the dst tensor.  Use SortCoo
       // if the COO tensor has the same ordering as the dst tensor.
-      if (dimRank > 1 && srcTp.hasSameDimToLvlMap(dstTp)) {
+      if (dimRank > 1 && srcTp.hasSameDimToLvl(dstTp)) {
         Value xs = genToCoordinatesBuffer(rewriter, loc, src);
         rewriter.create<SortCooOp>(
             loc, nnz, xs, ValueRange{y}, rewriter.getIndexAttr(dimRank),
             rewriter.getIndexAttr(0), SparseTensorSortKind::HybridQuickSort);
       } else {
         // Gather the coordinates-arrays in the dst tensor storage order.
         SmallVector<Value> xs(dstLvlRank);
         const Level srcLvlRank = srcTp.getLvlRank();
LogicalResult matchAndRewrite(NewOp op,
     const auto dstTp = getSparseTensorType(op.getResult());
     const auto encDst = dstTp.getEncoding();
     if (!dstTp.hasEncoding() || getCOOStart(encDst) == 0)
       return failure();
 
     // Implement the NewOp as follows:
     //   %orderedCoo = sparse_tensor.new %filename
     //   %t = sparse_tensor.convert %orderedCoo
-    RankedTensorType cooTp =
-        getCOOFromTypeWithOrdering(dstTp, encDst.getDimOrdering(), true);
+    RankedTensorType cooTp = getCOOType(dstTp, /*ordered=*/true);
     Value cooTensor = rewriter.create<NewOp>(loc, cooTp, op.getSource());
     Value convert = rewriter.replaceOpWithNewOp<ConvertOp>(
         op, dstTp.getRankedTensorType(), cooTensor);
 
     // Release the ordered COO tensor.
     rewriter.setInsertionPointAfterValue(convert);
     rewriter.create<DeallocTensorOp>(loc, cooTensor);
 

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

for (OpOperand *t : env.op().getDpsInputOperands()) {
       // Found an input tensor that resolves the cycle by inserting a
       // conversion into a sparse tensor that adheres to the iteration
       // graph order. Also releases the temporary sparse tensor.
       //
       // TODO: investigate fusing the conversion with computation,
       //       especially if it is a direct yield!
       //
       auto srcTp = getRankedTensorType(tval);
-      auto dstEnc = SparseTensorEncodingAttr::get(
-          getContext(), srcEnc.getLvlTypes(),
-          permute(env, env.op().getMatchingIndexingMap(t)), // new order
-          srcEnc.getHigherOrdering(), srcEnc.getPosWidth(),
-          srcEnc.getCrdWidth());
+      // TODO: This assertion is to match the behavior from prior to
+      // merging dimOrdering and higherOrdering into dimToLvl.  However,
+      // since `permute` returns a permutation, we can remove this
+      // restriction by instead composing the result of `permute`
+      // with `srcEnc.getDimToLvl`.
+      assert(srcEnc.isPermutation());
+      auto dstEnc =
+          srcEnc.withDimToLvl(permute(env, env.op().getMatchingIndexingMap(t)));
       auto dstTp = RankedTensorType::get(srcTp.getShape(),
                                          srcTp.getElementType(), dstEnc);
       auto convert = rewriter.create<ConvertOp>(tval.getLoc(), dstTp, tval);
       rewriter.updateRootInPlace(env.op(),
                                  [&]() { env.op()->setOperand(tid, convert); });
       rewriter.setInsertionPointAfter(env.op());
       rewriter.create<bufferization::DeallocTensorOp>(tval.getLoc(), convert);
       return success();

mlir/test/CAPI/sparse_tensor.c

 
 // CHECK-LABEL: testRoundtripEncoding()
 static int testRoundtripEncoding(MlirContext ctx) {
   fprintf(stderr, "testRoundtripEncoding()\n");
   // clang-format off
   const char *originalAsm =
     "#sparse_tensor.encoding<{ "
     "lvlTypes = [ \"dense\", \"compressed\", \"compressed\"], "
-    "dimOrdering = affine_map<(d0, d1, d2) -> (d0, d1, d2)>, "
-    "higherOrdering = affine_map<(d0, d1)[s0] -> (s0, d0, d1)>, "
+    "dimToLvl = affine_map<(d0, d1)[s0] -> (s0, d0, d1)>, "
     "posWidth = 32, crdWidth = 64 }>";
   // clang-format on
   MlirAttribute originalAttr =
       mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString(originalAsm));
   // CHECK: isa: 1
   fprintf(stderr, "isa: %d\n",
           mlirAttributeIsASparseTensorEncodingAttr(originalAttr));
-  MlirAffineMap dimOrdering =
-      mlirSparseTensorEncodingAttrGetDimOrdering(originalAttr);
-  // CHECK: (d0, d1, d2) -> (d0, d1, d2)
-  mlirAffineMapDump(dimOrdering);
-  MlirAffineMap higherOrdering =
-      mlirSparseTensorEncodingAttrGetHigherOrdering(originalAttr);
+  MlirAffineMap dimToLvl =
+      mlirSparseTensorEncodingAttrGetDimToLvl(originalAttr);
   // CHECK: (d0, d1)[s0] -> (s0, d0, d1)
-  mlirAffineMapDump(higherOrdering);
+  mlirAffineMapDump(dimToLvl);
   // CHECK: level_type: 4
   // CHECK: level_type: 8
   // CHECK: level_type: 8
   int lvlRank = mlirSparseTensorEncodingGetLvlRank(originalAttr);
   enum MlirSparseTensorDimLevelType *lvlTypes =
       malloc(sizeof(enum MlirSparseTensorDimLevelType) * lvlRank);
   for (int l = 0; l < lvlRank; ++l) {
     lvlTypes[l] = mlirSparseTensorEncodingAttrGetLvlType(originalAttr, l);
     fprintf(stderr, "level_type: %d\n", lvlTypes[l]);
   }
   // CHECK: posWidth: 32
   int posWidth = mlirSparseTensorEncodingAttrGetPosWidth(originalAttr);
   fprintf(stderr, "posWidth: %d\n", posWidth);
   // CHECK: crdWidth: 64
   int crdWidth = mlirSparseTensorEncodingAttrGetCrdWidth(originalAttr);
   fprintf(stderr, "crdWidth: %d\n", crdWidth);
 
   MlirAttribute newAttr = mlirSparseTensorEncodingAttrGet(
-      ctx, lvlRank, lvlTypes, dimOrdering, higherOrdering, posWidth, crdWidth);
+      ctx, lvlRank, lvlTypes, dimToLvl, posWidth, crdWidth);
   mlirAttributeDump(newAttr); // For debugging filecheck output.
   // CHECK: equal: 1
   fprintf(stderr, "equal: %d\n", mlirAttributeEqual(originalAttr, newAttr));
 
   free(lvlTypes);
   return 0;
 }
 

mlir/test/Dialect/SparseTensor/codegen.mlir

 }>
 
 #UCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed-no" ]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i, j) -> (j, i)>
+  dimToLvl = affine_map<(i, j) -> (j, i)>
 }>
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
   crdWidth = 64,
   posWidth = 32
 }>
 
 #Dense3D = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "dense", "dense" ],
-  dimOrdering = affine_map<(i, j, k) -> (k, i, j)>
+  dimToLvl = affine_map<(i, j, k) -> (k, i, j)>
 }>
 
 #Coo = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 #CooPNo = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton-no" ],
-  dimOrdering = affine_map<(i, j) -> (j, i)>
+  dimToLvl = affine_map<(i, j) -> (j, i)>
 }>
 
 #ccoo = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed-nu", "singleton" ]
 }>
 
 // CHECK-LABEL: func @sparse_nop(
 //  CHECK-SAME: %[[A0:.*]]: memref<?xi32>,
func.func @sparse_dense_3d(%arg0: tensor<10x20x30xf64, #Dense3D>) -> index {
   %c = arith.constant 1 : index
   %0 = tensor.dim %arg0, %c : tensor<10x20x30xf64, #Dense3D>
   return %0 : index
 }
 
 //
 // Querying for dimension 1 in the tensor type needs to be permuted
 // into querying for dimension 2 in the stored sparse tensor scheme,
-// since the latter honors the dimOrdering.
+// since the latter honors the dimToLvl mapping.
 //
 // CHECK-LABEL: func @sparse_dense_3d_dyn(
 //  CHECK-SAME: %[[A0:.*]]: memref<?xf64>,
 //  CHECK-SAME: %[[A1:.*]]: !sparse_tensor.storage_specifier
 //       CHECK: %[[A2:.*]] = sparse_tensor.storage_specifier.get %[[A1]] lvl_sz at 2
 //       CHECK: return %[[A2]] : index
 func.func @sparse_dense_3d_dyn(%arg0: tensor<?x?x?xf64, #Dense3D>) -> index {
   %c = arith.constant 1 : index

mlir/test/Dialect/SparseTensor/codegen_sparse_dealloc.mlir

 // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false" \
 // RUN:    --sparse-tensor-codegen=create-sparse-deallocs=false \
 // RUN:    --canonicalize --cse | FileCheck %s -check-prefix=CHECK-NO-DEALLOC
 
 // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false" \
 // RUN:    --sparse-tensor-codegen=create-sparse-deallocs=true \
 // RUN:    --canonicalize --cse | FileCheck %s -check-prefix=CHECK-DEALLOC
 
 #CSR = #sparse_tensor.encoding<{ lvlTypes = ["dense", "compressed"]}>
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // No memref.dealloc is user-requested so
 // CHECK-NO-DEALLOC-LABEL: @sparse_convert_permuted
 // CHECK-NO-DEALLOC-NOT: memref.dealloc
 //
 // Otherwise memref.dealloc is created to free temporary sparse buffers.
 // CHECK-DEALLOC-LABEL: @sparse_convert_permuted
 // CHECK-DEALLOC: memref.dealloc
 //
 func.func @sparse_convert_permuted(%arg0: tensor<?x?xf32, #CSR>) -> tensor<?x?xf32, #CSC> {
   %0 = sparse_tensor.convert %arg0 : tensor<?x?xf32, #CSR> to tensor<?x?xf32, #CSC>
   return %0 : tensor<?x?xf32, #CSC>
 }

mlir/test/Dialect/SparseTensor/conversion.mlir

 }>
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #SparseTensor = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed", "compressed"],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 // CHECK-LABEL: func @sparse_nop(
 //  CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>
 //       CHECK: return %[[A]] : !llvm.ptr<i8>
 func.func @sparse_nop(%arg0: tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> {
   return %arg0 : tensor<?xf64, #SparseVector>
 }

mlir/test/Dialect/SparseTensor/convert_dense2sparse.mlir

 // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
 // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \
 // RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT
 
 #SparseVector = #sparse_tensor.encoding<{
   lvlTypes = ["compressed"]
 }>
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i, j) -> (j, i)>
+  dimToLvl = affine_map<(i, j) -> (j, i)>
 }>
 
 #SparseTensor = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed", "compressed"],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 // CHECK-LABEL: func @sparse_convert_1d(
 //  CHECK-SAME: %[[A:.*]]: tensor<?xi32>) -> !llvm.ptr<i8> {
 //   CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32
 //   CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : i32
 //   CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index

mlir/test/Dialect/SparseTensor/convert_sparse2dense.mlir

 // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
 
 // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \
 // RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT
 
 #SparseVector = #sparse_tensor.encoding<{
   lvlTypes = ["compressed"]
 }>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"]
 }>
 
 #SparseTensor = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed", "compressed"],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 // CHECK-LABEL: func @sparse_convert_1d(
 //  CHECK-SAME: %[[Arg:.*]]: !llvm.ptr<i8>) -> tensor<13xi32>
 //   CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index
 //   CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index
 //   CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8
 //   CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32

mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir

 
 #SortedCOO3D = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ]
 
 }>
 
 #TsssPermuted = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 #COOSlice = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
   slice = [ (2, 2, 1), (12, 13, 1) ]
 }>
 
 // CHECK-LABEL: func @sparse_nop_convert(

mlir/test/Dialect/SparseTensor/invalid_encoding.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // expected-error@+1 {{expected a non-empty array for lvlTypes}}
 #a = #sparse_tensor.encoding<{lvlTypes = []}>
 func.func private @scalar(%arg0: tensor<f64, #a>) -> ()
 
 // -----
 
+// expected-error@+2 {{dimension-rank mismatch between encoding and tensor shape: 2 != 1}}
 #a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
-func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> () // expected-error {{expected an array of size 1 for lvlTypes}}
+func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
-#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimOrdering = affine_map<(i) -> (i)>}> // expected-error {{level-rank mismatch between dimOrdering and lvlTypes}}
+// expected-error@+1 {{level-rank mismatch between dimToLvl and lvlTypes: 1 != 2}}
+#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimToLvl = affine_map<(i) -> (i)>}>
 func.func private @tensor_sizes_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
 #a = #sparse_tensor.encoding<{lvlTypes = [1]}> // expected-error {{expected a string value in lvlTypes}}
 func.func private @tensor_type_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
 #a = #sparse_tensor.encoding<{lvlTypes = ["strange"]}> // expected-error {{unexpected level-type: strange}}
 func.func private @tensor_value_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
-#a = #sparse_tensor.encoding<{dimOrdering = "wrong"}> // expected-error {{expected an affine map for dimension ordering}}
-func.func private @tensor_dimorder_mismatch(%arg0: tensor<8xi32, #a>) -> ()
+#a = #sparse_tensor.encoding<{dimToLvl = "wrong"}> // expected-error {{expected an affine map for dimToLvl}}
+func.func private @tensor_dimtolvl_mismatch(%arg0: tensor<8xi32, #a>) -> ()
 
 // -----
 
-#a = #sparse_tensor.encoding<{higherOrdering = "wrong"}> // expected-error {{expected an affine map for higher ordering}}
-func.func private @tensor_highorder_mismatch(%arg0: tensor<8xi32, #a>) -> ()
-
-// -----
-
-// expected-error@+1 {{expected a permutation affine map for dimension ordering}}
-#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimOrdering = affine_map<(i,j) -> (i,i)>}>
+// expected-error@+1 {{expected a permutation affine map for dimToLvl}}
+#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimToLvl = affine_map<(i,j) -> (i,i)>}>
 func.func private @tensor_no_permutation(%arg0: tensor<16x32xf32, #a>) -> ()
 
 // -----
 
 #a = #sparse_tensor.encoding<{posWidth = "x"}> // expected-error {{expected an integral position bitwidth}}
 func.func private @tensor_no_int_ptr(%arg0: tensor<16x32xf32, #a>) -> ()
 
 // -----

 
 // -----
 
 #a = #sparse_tensor.encoding<{key = 1}> // expected-error {{unexpected key: key}}
 func.func private @tensor_invalid_key(%arg0: tensor<16x32xf32, #a>) -> ()
 
 // -----
 
-#a = #sparse_tensor.encoding<{lvlTypes = [ "compressed", "compressed", "dense", "dense" ], dimOrdering  = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>, higherOrdering = affine_map<(i, j) -> (j, i)>}> // expected-error {{unexpected higher ordering mapping from 2 to 2}}
-func.func private @tensor_invalid_key(%arg0: tensor<10x60xf32, #a>) -> ()
-
-// -----
-
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
   slice = [ (-1, ?, 1), (?, 4, 2) ] // expected-error{{expect positive value or ? for slice offset/size/stride}}
 }>
 func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)

mlir/test/Dialect/SparseTensor/one_shot_bufferize_tensor_copy_insertion.mlir

 // RUN: mlir-opt %s -test-tensor-copy-insertion="allow-return-allocs" | FileCheck %s
 // RUN: mlir-opt %s -test-tensor-copy-insertion="bufferize-function-boundaries allow-return-allocs" | FileCheck %s --check-prefix=CHECK-FUNC
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 // CHECK-LABEL: func @bufferization_alloc_tensor
 // CHECK-FUNC-LABEL: func @bufferization_alloc_tensor
 func.func @bufferization_alloc_tensor() -> tensor<20x40xf32, #DCSR> {
   // CHECK: bufferization.alloc_tensor() {bufferization.escape = [false]}
   // CHECK-FUNC: bufferization.alloc_tensor() {bufferization.escape = [true]}
   %0 = bufferization.alloc_tensor() : tensor<20x40xf32, #DCSR>

mlir/test/Dialect/SparseTensor/rewriting_for_codegen.mlir

 // RUN: mlir-opt %s -post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" | \
 // RUN: FileCheck %s
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i, j) -> (j, i)>
+  dimToLvl = affine_map<(i, j) -> (j, i)>
 }>
 
 #COO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 // CHECK-LABEL:   func.func @sparse_new(
 // CHECK-SAME:    %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>> {
 // CHECK:         %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>
 // CHECK:         %[[R:.*]] = sparse_tensor.convert %[[COO]]
 // CHECK:         bufferization.dealloc_tensor %[[COO]]
 // CHECK:         return %[[R]]
 func.func @sparse_new(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSR> {
   %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSR>
   return %0 : tensor<?x?xf32, #CSR>
 }
 
 // CHECK-LABEL:   func.func @sparse_new_csc(
-// CHECK-SAME:    %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> {
-// CHECK:         %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
+// CHECK-SAME:    %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> {
+// CHECK:         %[[COO:.*]] = sparse_tensor.new %[[A]] : !llvm.ptr<i8> to tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>>
 // CHECK:         %[[R:.*]] = sparse_tensor.convert %[[COO]]
 // CHECK:         bufferization.dealloc_tensor %[[COO]]
 // CHECK:         return %[[R]]
 func.func @sparse_new_csc(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSC> {
   %0 = sparse_tensor.new %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSC>
   return %0 : tensor<?x?xf32, #CSC>
 }
 

mlir/test/Dialect/SparseTensor/roundtrip_encoding.mlir

 // RUN: mlir-opt %s -split-input-file | mlir-opt | FileCheck %s
 
 // CHECK-LABEL: func private @sparse_1d_tensor(
 // CHECK-SAME: tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>>)
 func.func private @sparse_1d_tensor(tensor<32xf64, #sparse_tensor.encoding<{ lvlTypes = ["compressed"] }>>)
 
 // -----
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>,
+  dimToLvl = affine_map<(i,j) -> (i,j)>,
   posWidth = 64,
   crdWidth = 64
 }>
 
 // CHECK-LABEL: func private @sparse_csr(
 // CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], posWidth = 64, crdWidth = 64 }>>)
 func.func private @sparse_csr(tensor<?x?xf32, #CSR>)
 
 // -----
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>,
+  dimToLvl = affine_map<(i,j) -> (j,i)>,
   posWidth = 0,
   crdWidth = 0
 }>
 
 // CHECK-LABEL: func private @sparse_csc(
-// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>)
+// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>>)
 func.func private @sparse_csc(tensor<?x?xf32, #CSC>)
 
 // -----
 
 #DCSC = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>,
+  dimToLvl = affine_map<(i,j) -> (j,i)>,
   posWidth = 0,
   crdWidth = 64
 }>
 
 // CHECK-LABEL: func private @sparse_dcsc(
-// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, crdWidth = 64 }>>)
+// CHECK-SAME: tensor<?x?xf32, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)>, crdWidth = 64 }>>)
 func.func private @sparse_dcsc(tensor<?x?xf32, #DCSC>)
 
 // -----
 
 #COO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu-no", "singleton-no" ]
 }>
 

 // CHECK-LABEL: func private @sparse_sorted_coo(
 // CHECK-SAME: tensor<10x10xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ] }>>)
 func.func private @sparse_sorted_coo(tensor<10x10xf64, #SortedCOO>)
 
 // -----
 
 #BCSR = #sparse_tensor.encoding<{
    lvlTypes = [ "compressed", "compressed", "dense", "dense" ],
-   dimOrdering  = affine_map<(ii, jj, i, j) -> (ii, jj, i, j)>,
-   higherOrdering = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)>
+   dimToLvl  = affine_map<(i, j) -> (i floordiv 2, j floordiv 3, i mod 2, j mod 3)>
 }>
 
 // CHECK-LABEL: func private @sparse_bcsr(
-// CHECK-SAME: tensor<10x60xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense", "dense" ], higherOrdering = affine_map<(d0, d1) -> (d0 floordiv 2, d1 floordiv 3, d0 mod 2, d1 mod 3)> }>>
+// CHECK-SAME: tensor<10x60xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "dense", "dense" ], dimToLvl = affine_map<(d0, d1) -> (d0 floordiv 2, d1 floordiv 3, d0 mod 2, d1 mod 3)> }>>
 func.func private @sparse_bcsr(tensor<10x60xf64, #BCSR>)
 
 
 // -----
 
 #ELL = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "dense", "compressed" ],
-  dimOrdering  = affine_map<(ii, i, j) -> (ii, i, j)>,
-  higherOrdering = affine_map<(i,j)[c] -> (c*4*i, i, j)>
+  dimToLvl = affine_map<(i,j)[c] -> (c*4*i, i, j)>
 }>
 
 // CHECK-LABEL: func private @sparse_ell(
-// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ], higherOrdering = affine_map<(d0, d1)[s0] -> (d0 * (s0 * 4), d0, d1)> }>>
+// CHECK-SAME: tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense", "compressed" ], dimToLvl = affine_map<(d0, d1)[s0] -> (d0 * (s0 * 4), d0, d1)> }>>
 func.func private @sparse_ell(tensor<?x?xf64, #ELL>)
 
 // -----
 
 #CSR_SLICE = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
   slice = [ (1, 4, 1), (1, 4, 2) ]
 }>

mlir/test/Dialect/SparseTensor/sparse_concat.mlir

 // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
 
 #SparseMatrix = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
 
 #SparseMatrix_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #SparseMatrix_D_P = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 // CHECK-LABEL: func.func @concat_mix_dense(
 // CHECK-SAME:    %[[TMP_arg0:.*]]: tensor<2x4xf64>,
 // CHECK-SAME:    %[[TMP_arg1:.*]]: !llvm.ptr<i8>)
 // CHECK-DAG:     %[[TMP_c2:.*]] = arith.constant 2 : index
 // CHECK-DAG:     %[[TMP_c6_i32:.*]] = arith.constant 6 : i32
 // CHECK-DAG:     %[[TMP_c1_i32:.*]] = arith.constant 1 : i32

mlir/test/Dialect/SparseTensor/sparse_concat_codegen.mlir

 // RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" \
 // RUN: | FileCheck %s
 
 #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
 #DENSE = #sparse_tensor.encoding<{lvlTypes = ["dense", "dense"]}>
 #DENSE_P = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "dense"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 // CHECK-LABEL: @concat_sparse_sparse(
 //  CHECK-SAME:  %[[TMP_arg0:.*]]: tensor<2x4xf64, #sparse_tensor
 //  CHECK-SAME:  %[[TMP_arg1:.*]]: tensor<3x4xf64, #sparse_tensor
 //  CHECK-SAME:  %[[TMP_arg2:.*]]: tensor<4x4xf64, #sparse_tensor
 //       CHECK:  %[[TMP_c0:.*]] = arith.constant 0 : index
 //       CHECK:  %[[TMP_c1:.*]] = arith.constant 1 : index
 //       CHECK:  %[[TMP_c5:.*]] = arith.constant 5 : index

 //       CHECK:    scf.for %[[TMP_arg4:.*]] = %[[TMP_25]] to %[[TMP_26]] step %[[TMP_c1]]
 //       CHECK:      %[[TMP_27:.*]] = memref.load %[[TMP_18]][%[[TMP_arg4]]] : memref<?xindex>
 //       CHECK:      %[[TMP_28:.*]] = memref.load %[[TMP_19]][%[[TMP_arg4]]] : memref<?xf64>
 //       CHECK:      %[[TMP_29:.*]] = arith.addi %[[TMP_23]], %[[TMP_c5]] : index
 //       CHECK:      memref.store %[[TMP_28]], %[[VAL_1]][%[[TMP_27]], %[[TMP_29]]] : memref<?x?xf64>
 //       CHECK:    }
 //       CHECK:  }
 //       CHECK:  %[[R:.*]] = sparse_tensor.convert %[[TMP_0]]
-//       CHECK:  return %[[R]] : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
+//       CHECK:  return %[[R]] : tensor<?x?xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "dense" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>>
 func.func @concat_sparse_sparse_annotated_dense_permute(%arg0: tensor<2x4xf64, #DCSR>,
                                 %arg1: tensor<3x4xf64, #DCSR>,
                                 %arg2: tensor<4x4xf64, #DCSR>)
                                 -> tensor<?x?xf64, #DENSE_P> {
     %0 = sparse_tensor.concatenate %arg0, %arg1, %arg2 {dimension = 0 : index}
          : tensor<2x4xf64, #DCSR>,
            tensor<3x4xf64, #DCSR>,
            tensor<4x4xf64, #DCSR> to tensor<?x?xf64, #DENSE_P>
     return %0 : tensor<?x?xf64, #DENSE_P>
 }

mlir/test/Dialect/SparseTensor/sparse_expand.mlir

 // RUN: mlir-opt %s --linalg-generalize-named-ops \
 // RUN:             --linalg-fuse-elementwise-ops \
 // RUN:             --sparsification | \
 // RUN:   FileCheck %s --check-prefix=CHECK-SPARSE
 // RUN: mlir-opt %s --linalg-generalize-named-ops \
 // RUN:             --linalg-fuse-elementwise-ops \
 // RUN:             --sparsification --sparse-tensor-conversion --cse | \
 // RUN:   FileCheck %s --check-prefix=CHECK-CONVERT
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [  "dense", "compressed" ]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [  "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #DCSC = #sparse_tensor.encoding<{
   lvlTypes = [  "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #SV = #sparse_tensor.encoding<{
   lvlTypes = [  "compressed" ]
 }>
 
 #rowsum = {
   indexing_maps = [

mlir/test/Dialect/SparseTensor/sparse_lower_col.mlir

 // RUN: mlir-opt %s -sparsification | FileCheck %s --check-prefix=CHECK-HIR
 //
 // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse | \
 // RUN: FileCheck %s --check-prefix=CHECK-MIR
 //
 // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --cse \
 // RUN: --func-bufferize --arith-bufferize           \
 // RUN: --tensor-bufferize --finalizing-bufferize |  \
 // RUN: FileCheck %s --check-prefix=CHECK-LIR
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #trait_matvec = {
   indexing_maps = [
     affine_map<(i,j) -> (i,j)>,  // A
     affine_map<(i,j) -> (j)>,    // b
     affine_map<(i,j) -> (i)>     // x (out)
   ],
   iterator_types = ["parallel","reduction"],
   doc = "x(i) += A(i,j) * b(j)"
 }
 
 // CHECK-HIR-LABEL:   func @matvec(
-// CHECK-HIR-SAME:                 %[[VAL_0:.*]]: tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>,
+// CHECK-HIR-SAME:                 %[[VAL_0:.*]]: tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>>,
 // CHECK-HIR-SAME:                 %[[VAL_1:.*]]: tensor<64xf64>,
 // CHECK-HIR-SAME:                 %[[VAL_2:.*]]: tensor<32xf64>) -> tensor<32xf64> {
 // CHECK-HIR-DAG:       %[[VAL_3:.*]] = arith.constant 64 : index
 // CHECK-HIR-DAG:       %[[VAL_4:.*]] = arith.constant 0 : index
 // CHECK-HIR-DAG:       %[[VAL_5:.*]] = arith.constant 1 : index
-// CHECK-HIR-DAG:       %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
-// CHECK-HIR-DAG:       %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
-// CHECK-HIR-DAG:       %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64>
+// CHECK-HIR-DAG:       %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
+// CHECK-HIR-DAG:       %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 1 : index} : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
+// CHECK-HIR-DAG:       %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x64xf64, #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64>
 // CHECK-HIR-DAG:       %[[VAL_9:.*]] = bufferization.to_memref %[[VAL_1]] : memref<64xf64>
 // CHECK-HIR-DAG:       %[[VAL_11:.*]] = bufferization.to_memref %[[VAL_2]] : memref<32xf64>
 // CHECK-HIR:           scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK-HIR-DAG:         %[[VAL_13:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_12]]] : memref<64xf64>
 // CHECK-HIR-DAG:         %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
 // CHECK-HIR-DAG:         %[[VAL_15:.*]] = arith.addi %[[VAL_12]], %[[VAL_5]] : index
 // CHECK-HIR-DAG:         %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK-HIR:             scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_5]] {

mlir/test/Dialect/SparseTensor/sparse_matmul_codegen.mlir

 // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
 
 // RUN: mlir-opt %s --linalg-generalize-named-ops \
 // RUN:  --sparsification --sparse-tensor-codegen \
 // RUN:  --canonicalize --cse | FileCheck %s
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 //
 // Computes C = A x B with all matrices sparse (SpMSpM) in CSR.
 //
 // CHECK-LABEL:   func.func private @_insert_dense_compressed_4_4_f64_0_0(
 // CHECK-SAME:      %[[VAL_0:.*0]]: memref<?xindex>,
 // CHECK-SAME:      %[[VAL_1:.*1]]: memref<?xindex>,

mlir/test/Dialect/SparseTensor/sparse_out.mlir

 // RUN: mlir-opt %s -sparsification | FileCheck %s
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 #SparseTensor = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ]
 }>
 
 #trait_scale_inpl = {
   indexing_maps = [

mlir/test/Dialect/SparseTensor/sparse_perm.mlir

 // NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
 // RUN: mlir-opt %s -sparsification | FileCheck %s
 
 #X = #sparse_tensor.encoding<{
  lvlTypes = [ "dense", "dense", "dense" ],
- dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+ dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 #trait = {
   indexing_maps = [
     affine_map<(i,j,k) -> (k,i,j)>,  // A (in)
     affine_map<(i,j,k) -> (i,j,k)>   // X (out)
   ],
   iterator_types = ["parallel", "parallel", "parallel"]

mlir/test/Dialect/SparseTensor/sparse_perm_lower.mlir

 // RUN: mlir-opt %s -sparsification --canonicalize | FileCheck %s --check-prefix=CHECK-HIR
 //
 // RUN: mlir-opt %s -sparsification --sparse-tensor-conversion --canonicalize | \
 // RUN: FileCheck %s --check-prefix=CHECK-MIR
 
 #X = #sparse_tensor.encoding<{
  lvlTypes = [ "dense", "dense", "dense" ],
- dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+ dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 #trait = {
   indexing_maps = [
     affine_map<(i,j,k) -> (k,i,j)>,  // A (in)
     affine_map<(i,j,k) -> ()>        // X (out)
   ],
   iterator_types = ["reduction", "reduction", "reduction"]

mlir/test/Dialect/SparseTensor/sparse_transpose.mlir

 
 // TODO: improve auto-conversion followed by yield
 
 // CHECK-LABEL:   func.func @sparse_transpose_auto(
 // CHECK-SAME:      %[[VAL_0:.*]]: tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) -> tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> {
 // CHECK-DAG:       %[[VAL_1:.*]] = arith.constant 0 : index
 // CHECK-DAG:       %[[VAL_2:.*]] = arith.constant 1 : index
 // CHECK-DAG:       %[[VAL_3:.*]] = bufferization.alloc_tensor() : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
-// CHECK-DAG:       %[[VAL_4:.*]] = sparse_tensor.convert %[[VAL_0]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
-// CHECK-DAG:       %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
-// CHECK-DAG:       %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
-// CHECK-DAG:       %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
-// CHECK-DAG:       %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
-// CHECK-DAG:       %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64>
+// CHECK-DAG:       %[[VAL_4:.*]] = sparse_tensor.convert %[[VAL_0]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>> to tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>>
+// CHECK-DAG:       %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
+// CHECK-DAG:       %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 0 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
+// CHECK-DAG:       %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
+// CHECK-DAG:       %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_4]] {level = 1 : index} : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xindex>
+// CHECK-DAG:       %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>> to memref<?xf64>
 // CHECK:           %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_1]]] : memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_2]]] : memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = scf.for %[[VAL_13:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_2]] iter_args(%[[VAL_14:.*]] = %[[VAL_3]]) -> (tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
 // CHECK:             %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK:             %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK:             %[[VAL_17:.*]] = arith.addi %[[VAL_13]], %[[VAL_2]] : index
 // CHECK:             %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex>
 // CHECK:             %[[VAL_19:.*]] = scf.for %[[VAL_20:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_2]] iter_args(%[[VAL_21:.*]] = %[[VAL_14]]) -> (tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>) {
 // CHECK:               %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex>
 // CHECK:               %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_20]]] : memref<?xf64>
 // CHECK:               %[[VAL_24:.*]] = sparse_tensor.insert %[[VAL_23]] into %[[VAL_21]]{{\[}}%[[VAL_15]], %[[VAL_22]]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
 // CHECK:               scf.yield %[[VAL_24]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
 // CHECK:             }
 // CHECK:             scf.yield %[[VAL_25:.*]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
 // CHECK:           }
 // CHECK:           %[[VAL_26:.*]] = sparse_tensor.load %[[VAL_27:.*]] hasInserts : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
-// CHECK:           bufferization.dealloc_tensor %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)> }>>
+// CHECK:           bufferization.dealloc_tensor %[[VAL_4]] : tensor<3x4xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)> }>>
 // CHECK:           return %[[VAL_26]] : tensor<4x3xf64, #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>>
 // CHECK:         }
 func.func @sparse_transpose_auto(%arga: tensor<3x4xf64, #DCSR>)
                                      -> tensor<4x3xf64, #DCSR> {
   %i = bufferization.alloc_tensor() : tensor<4x3xf64, #DCSR>
   %0 = linalg.generic #transpose_trait
      ins(%arga: tensor<3x4xf64, #DCSR>)
      outs(%i: tensor<4x3xf64, #DCSR>) {
      ^bb(%a: f64, %x: f64):
        linalg.yield %a : f64
   } -> tensor<4x3xf64, #DCSR>
   return %0 : tensor<4x3xf64, #DCSR>
 }

mlir/test/Dialect/SparseTensor/sparse_vector_concat.mlir

 // RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
 
 #MAT_D_C = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "compressed"]
 }>
 
 #MAT_C_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_D_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // Ensures only last loop is vectorized
 // (vectorizing the others would crash).
 //
 // CHECK-LABEL: llvm.func @foo
 // CHECK:       llvm.intr.masked.load

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_0.mlir

 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
 #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
 #MAT_D_D = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "dense"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_D_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_D_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
   func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
 
   //
   // Tests without permutation.

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_0_permute.mlir

 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
 #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
 #MAT_D_D = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "dense"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_D_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_D_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
   func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
 
   //
   // Tests with permutation.

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_1.mlir

 // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true"
 // RUN: %{compile} | %{run}
 
 #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
 #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
 #MAT_D_D = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "dense"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_D_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_D_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
   func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
 
   //
   // Tests without permutation (concatenate on dimension 1)

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_1_permute.mlir

 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
 #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
 #MAT_D_D = #sparse_tensor.encoding<{
   lvlTypes = ["dense", "dense"],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_C_D_P = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #MAT_D_C_P = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
   func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
 
   //
   // Tests with permutation (concatenate on dimension 1)

mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output.mlir

 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 !Filename = !llvm.ptr<i8>
 
 #DenseMatrix = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 #trait_assign = {
   indexing_maps = [
     affine_map<(i,j) -> (i,j)>, // A
     affine_map<(i,j) -> (i,j)>  // X (out)
   ],
   iterator_types = ["parallel", "parallel"],

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_codegen_foreach.mlir

 }>
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ]
 }>
 
 #DCSC = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #SortedCOO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 #SortedCOOPerm = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #CCCPerm = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed"],
-  dimOrdering = affine_map<(d0, d1, d2) -> (d1, d2, d0)>
+  dimToLvl = affine_map<(d0, d1, d2) -> (d1, d2, d0)>
 }>
 
 module {
   /// uses foreach operator to print coords and values.
   func.func @foreach_print_const() {
     // Initialize a tensor.
     %0 = arith.constant sparse<[[0, 0], [1, 6]], [1.0, 5.0]> : tensor<8x7xf32>
     sparse_tensor.foreach in %0 : tensor<8x7xf32> do {

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conv_1d_nwc_wcf.mlir

 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #CCC = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ] }>
 
 #CDC = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense", "compressed" ]
   // FIXME: Still inadmissible might need investigation
-  // dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
+  // dimToLvl = affine_map<(i,j,k) -> (j,k,i)>
 }>
 
 // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
 func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> tensor<?x?x?xf32> {
   %buf = bufferization.alloc_tensor(%s1, %s2, %s3) : tensor<?x?x?xf32>
   %ret = linalg.fill ins(%f : f32) outs(%buf : tensor<?x?x?xf32>) -> tensor<?x?x?xf32>
   return %ret : tensor<?x?x?xf32>
 }

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conv_2d.mlir

 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
 #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #CDR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 // An example of a 2D convolution with a sparse filter.
 module {
 
   func.func @conv2d(%input:  tensor<8x8xi32>,
                %filter: tensor<3x3xi32>,
                %output: tensor<6x6xi32>) -> tensor<6x6xi32> {

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion.mlir

 // REDEFINE:   --extra-module=%S/Inputs/main_for_lli.ll \
 // REDEFINE:   %VLA_ARCH_ATTR_OPTIONS \
 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #Tensor1  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
+  dimToLvl = affine_map<(i,j,k) -> (i,j,k)>
 }>
 
 #Tensor2  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
+  dimToLvl = affine_map<(i,j,k) -> (j,k,i)>
 }>
 
 #Tensor3  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 //
 // Integration test that tests conversions between sparse tensors.
 //
 module {
   //
   // Output utilities.

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion_dyn.mlir

 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #DCSR  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ]
 }>
 
 #DCSC  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // Integration test that tests conversions between sparse tensors,
 // where the dynamic sizes of the shape of the enveloping tensor
 // may change (the actual underlying sizes obviously never change).
 //
 module {

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion_element.mlir

 }>
 
 #Tensor2 = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed", "dense" ]
 }>
 
 #Tensor3 = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (i,k,j)>
+  dimToLvl = affine_map<(i,j,k) -> (i,k,j)>
 }>
 
 module {
   //
   // Utility for output.
   //
   func.func @dump(%arg0: tensor<2x3x4xf32>) {
     %c0 = arith.constant 0 : index

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion_ptr.mlir

 #DCSR  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
   posWidth = 8,
   crdWidth = 8
 }>
 
 #DCSC  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>,
+  dimToLvl = affine_map<(i,j) -> (j,i)>,
   posWidth = 64,
   crdWidth = 64
 }>
 
 #CSC  = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>,
+  dimToLvl = affine_map<(i,j) -> (j,i)>,
   posWidth = 16,
   crdWidth = 32
 }>
 
 //
 // Integration test that tests conversions between sparse tensors,
 // where the position and index sizes in the overhead storage change
 // in addition to layout.

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion_sparse2dense.mlir

 // REDEFINE:   --extra-module=%S/Inputs/main_for_lli.ll \
 // REDEFINE:   %VLA_ARCH_ATTR_OPTIONS \
 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #Tensor1  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
+  dimToLvl = affine_map<(i,j,k) -> (i,j,k)>
 }>
 
 #Tensor2  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
+  dimToLvl = affine_map<(i,j,k) -> (j,k,i)>
 }>
 
 #Tensor3  = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 #Tensor4  = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
+  dimToLvl = affine_map<(i,j,k) -> (i,j,k)>
 }>
 
 #Tensor5  = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (j,k,i)>
+  dimToLvl = affine_map<(i,j,k) -> (j,k,i)>
 }>
 
 #Tensor6  = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 //
 // Integration test that tests conversions from sparse to dense tensors.
 //
 module {
   //
   // Utilities for output.

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion_sparse2sparse.mlir

 // NOTE: dense after compressed is not currently supported for the target
 // of direct-sparse2sparse conversion.  (It's fine for the source though.)
 #Tensor2 = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed", "dense" ]
 }>
 
 #Tensor3 = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j,k) -> (i,k,j)>
+  dimToLvl = affine_map<(i,j,k) -> (i,k,j)>
 }>
 
 #SingletonTensor1 = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed", "singleton" ]
 }>
 
 // This also checks the compressed->dense conversion (when there are zeros).
 #SingletonTensor2 = #sparse_tensor.encoding<{

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_expand.mlir

 // REDEFINE:   --extra-module=%S/Inputs/main_for_lli.ll \
 // REDEFINE:   %VLA_ARCH_ATTR_OPTIONS \
 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
 
   //
   // Column-wise storage forces the ijk loop to permute into jki
   // so that access pattern expansion (workspace) needs to be

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_flatten.mlir

 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 !Filename = !llvm.ptr<i8>
 
 #SparseTensor = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed", "compressed", "compressed",
                    "compressed", "compressed", "compressed", "compressed" ],
-  // Note that any dimOrdering permutation should give the same results
+  // Note that any dimToLvl permutation should give the same results
   // since, even though it impacts the sparse storage scheme layout,
   // it should not change the semantics.
-  dimOrdering = affine_map<(i,j,k,l,m,n,o,p) -> (p,o,j,k,i,l,m,n)>
+  dimToLvl = affine_map<(i,j,k,l,m,n,o,p) -> (p,o,j,k,i,l,m,n)>
 }>
 
 #trait_flatten = {
   indexing_maps = [
     affine_map<(i,j,k,l,m,n,o,p) -> (i,j,k,l,m,n,o,p)>, // A
     affine_map<(i,j,k,l,m,n,o,p) -> (i,j)>              // X (out)
   ],
   iterator_types = [ "parallel",  "parallel",  "reduction", "reduction",

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_matmul.mlir

 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 // TODO: Investigate the output generated for SVE, see https://github.com/llvm/llvm-project/issues/60626
 
 #CSR = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 module {
   func.func private @printMemrefF64(%ptr : tensor<*xf64>)
   func.func private @printMemref1dF64(%ptr : memref<?xf64>) attributes { llvm.emit_c_interface }
 
   //
   // Computes C = A x B with all matrices dense.

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_out_simple.mlir

 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 !Filename = !llvm.ptr<i8>
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (i,j)>
+  dimToLvl = affine_map<(i,j) -> (i,j)>
 }>
 
 #eltwise_mult = {
   indexing_maps = [
     affine_map<(i,j) -> (i,j)>  // X (out)
   ],
   iterator_types = ["parallel", "parallel"],
   doc = "X(i,j) *= X(i,j)"

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_reduce_custom.mlir

 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 // Reduction in this file _are_ supported by the AArch64 SVE backend
 
 #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
 #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // Traits for tensor operations.
 //
 #trait_matmul = {
   indexing_maps = [
     affine_map<(i,j,k) -> (i,k)>, // A

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_reduce_custom_prod.mlir

 // Product reductions - kept in a seperate file as these are not supported by
 // the AArch64 SVE backend (so the set-up is a bit different to
 // sparse_reducitons.mlir)
 
 #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
 #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // Traits for tensor operations.
 //
 
 #trait_mat_reduce_rowwise = {
   indexing_maps = [

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_select.mlir

 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
 #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // Traits for tensor operations.
 //
 #trait_vec_select = {
   indexing_maps = [
     affine_map<(i) -> (i)>, // A

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sorted_coo.mlir

 !Filename = !llvm.ptr<i8>
 
 #SortedCOO = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ]
 }>
 
 #SortedCOOPermuted = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #SortedCOO3D = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ]
 }>
 
 #SortedCOO3DPermuted = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ],
-  dimOrdering = affine_map<(i,j,k) -> (k,i,j)>
+  dimToLvl = affine_map<(i,j,k) -> (k,i,j)>
 }>
 
 #trait_scale = {
   indexing_maps = [
     affine_map<(i,j) -> (i,j)>  // X (out)
   ],
   iterator_types = ["parallel", "parallel"],
   doc = "X(i,j) = X(i,j) * 2.0"

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_storage.mlir

 }>
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   lvlTypes = [ "dense", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #DCSC = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #BlockRow = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ]
 }>
 
 #BlockCol = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "dense" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 //
 // Integration test that looks "under the hood" of sparse storage schemes.
 //
 module {
   //
   // Main driver that initializes a sparse tensor and inspects the sparse

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_transpose.mlir

 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
 #DCSR = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ]
 }>
 
 #DCSC = #sparse_tensor.encoding<{
   lvlTypes = [ "compressed", "compressed" ],
-  dimOrdering = affine_map<(i,j) -> (j,i)>
+  dimToLvl = affine_map<(i,j) -> (j,i)>
 }>
 
 #transpose_trait = {
   indexing_maps = [
     affine_map<(i,j) -> (j,i)>,  // A
     affine_map<(i,j) -> (i,j)>   // X
   ],
   iterator_types = ["parallel", "parallel"],

mlir/test/Integration/Dialect/SparseTensor/python/test_SDDMM.py

with ir.Context() as ctx, ir.Location.unknown():
             ir.AffineMap.get_permutation([1, 0]),
         ]
         for level in levels:
             for ordering in orderings:
                 for pwidth in [32]:
                     for iwidth in [32]:
                         for e in [True]:
                             attr = st.EncodingAttr.get(
-                                level, ordering, None, pwidth, iwidth
+                                level, ordering, pwidth, iwidth
                             )
                             opt = f"parallelization-strategy=none"
                             compiler = sparse_compiler.SparseCompiler(
                                 options=opt, opt_level=0, shared_libs=[support_lib]
                             )
                             build_compile_and_run_SDDMMM(attr, compiler)
                             count = count + 1
     # CHECK: Passed 8 tests
     print("Passed ", count, "tests")
 
 
 if __name__ == "__main__":
     main()

mlir/test/Integration/Dialect/SparseTensor/python/test_SpMM.py

with ir.Context() as ctx, ir.Location.unknown():
         compiler = sparse_compiler.SparseCompiler(
             options=opt, opt_level=0, shared_libs=[support_lib]
         )
         for level in levels:
             for ordering in orderings:
                 for pwidth in bitwidths:
                     for iwidth in bitwidths:
                         attr = st.EncodingAttr.get(
-                            level, ordering, None, pwidth, iwidth
+                            level, ordering, pwidth, iwidth
                         )
                         build_compile_and_run_SpMM(attr, compiler)
                         count = count + 1
         # CHECK: Passed 8 tests
         print("Passed ", count, "tests")
 
 
 if __name__ == "__main__":
     main()

mlir/test/Integration/Dialect/SparseTensor/python/test_output.py

with ir.Context() as ctx, ir.Location.unknown():
         ]
         bitwidths = [8, 16, 32, 64]
         compiler = sparse_compiler.SparseCompiler(
             options="", opt_level=2, shared_libs=[support_lib]
         )
         for level in levels:
             for ordering in orderings:
                 for bwidth in bitwidths:
-                    attr = st.EncodingAttr.get(level, ordering, None, bwidth, bwidth)
+                    attr = st.EncodingAttr.get(level, ordering, bwidth, bwidth)
                     build_compile_and_run_output(attr, compiler)
                     count = count + 1
 
     # CHECK: Passed 16 tests
     print("Passed", count, "tests")
 
 
 if __name__ == "__main__":
     main()

mlir/test/Integration/Dialect/SparseTensor/python/test_stress.py

with ir.Context() as ctx, ir.Location.unknown():
         bitwidths = [0]
         # The first type must be a dense tensor for numpy conversion to work.
         types = [ir.RankedTensorType.get(shape, f64)]
         for level in levels:
             for ordering in orderings:
                 for pwidth in bitwidths:
                     for iwidth in bitwidths:
                         attr = st.EncodingAttr.get(
-                            level, ordering, None, pwidth, iwidth
+                            level, ordering, pwidth, iwidth
                         )
                         types.append(ir.RankedTensorType.get(shape, f64, attr))
         #
         # For exhaustiveness we should have one or more StressTest, such
         # that their paths cover all 2*n*(n-1) directed pairwise combinations
         # of the `types` set.  However, since n is already superexponential,
         # such exhaustiveness would be prohibitive for a test that runs on
         # every commit.  So for now we'll just pick one particular path that

mlir/test/Integration/Dialect/SparseTensor/taco/tools/mlir_pytaco.py

def mlir_tensor_attr(self) -> Optional[sparse_tensor.EncodingAttr]:
         """Constructs the MLIR attributes for the tensor format."""
         order = (
             range(self.rank()) if (self.ordering is None) else self.ordering.ordering
         )
         mlir_storage_format = [f.value for f in self.format_pack.formats]
         return sparse_tensor.EncodingAttr.get(
             mlir_storage_format,
             ir.AffineMap.get_permutation(order),
-            None,
             _POS_WIDTH,
             _CRD_WIDTH,
         )
 
 
 def _make_format(
     formats: List[ModeFormat], ordering: Optional[List[int]] = None
 ) -> Format:

mlir/test/python/dialects/sparse_tensor/dialect.py

with Context() as ctx:
         print(parsed)
 
         casted = st.EncodingAttr(parsed)
         # CHECK: equal: True
         print(f"equal: {casted == parsed}")
 
         # CHECK: lvl_types: [<DimLevelType.compressed: 8>]
         print(f"lvl_types: {casted.lvl_types}")
-        # CHECK: dim_ordering: None
-        print(f"dim_ordering: {casted.dim_ordering}")
+        # CHECK: dim_to_lvl: None
+        print(f"dim_to_lvl: {casted.dim_to_lvl}")
         # CHECK: pos_width: 16
         print(f"pos_width: {casted.pos_width}")
         # CHECK: crd_width: 32
         print(f"crd_width: {casted.crd_width}")
 
-        created = st.EncodingAttr.get(casted.lvl_types, None, None, 0, 0)
+        created = st.EncodingAttr.get(casted.lvl_types, None, 0, 0)
         # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
         print(created)
         # CHECK: created_equal: False
         print(f"created_equal: {created == casted}")
 
         # Verify that the factory creates an instance of the proper type.
         # CHECK: is_proper_instance: True
         print(f"is_proper_instance: {isinstance(created, st.EncodingAttr)}")
         # CHECK: created_pos_width: 0
         print(f"created_pos_width: {created.pos_width}")
 
 
 # CHECK-LABEL: TEST: testEncodingAttr2D
 @run
 def testEncodingAttr2D():
     with Context() as ctx:
         parsed = Attribute.parse(
             "#sparse_tensor.encoding<{"
             '  lvlTypes = [ "dense", "compressed" ],'
-            "  dimOrdering = affine_map<(d0, d1) -> (d1, d0)>,"
+            "  dimToLvl = affine_map<(d0, d1) -> (d1, d0)>,"
             "  posWidth = 8,"
             "  crdWidth = 32"
             "}>"
         )
-        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
+        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
         print(parsed)
 
         casted = st.EncodingAttr(parsed)
         # CHECK: equal: True
         print(f"equal: {casted == parsed}")
 
         # CHECK: lvl_types: [<DimLevelType.dense: 4>, <DimLevelType.compressed: 8>]
         print(f"lvl_types: {casted.lvl_types}")
-        # CHECK: dim_ordering: (d0, d1) -> (d1, d0)
-        print(f"dim_ordering: {casted.dim_ordering}")
+        # CHECK: dim_to_lvl: (d0, d1) -> (d1, d0)
+        print(f"dim_to_lvl: {casted.dim_to_lvl}")
         # CHECK: pos_width: 8
         print(f"pos_width: {casted.pos_width}")
         # CHECK: crd_width: 32
         print(f"crd_width: {casted.crd_width}")
 
         created = st.EncodingAttr.get(
-            casted.lvl_types, casted.dim_ordering, casted.higher_ordering, 8, 32
+            casted.lvl_types, casted.dim_to_lvl, 8, 32
         )
-        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimOrdering = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
+        # CHECK: #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ], dimToLvl = affine_map<(d0, d1) -> (d1, d0)>, posWidth = 8, crdWidth = 32 }>
         print(created)
         # CHECK: created_equal: True
         print(f"created_equal: {created == casted}")
 
 
 # CHECK-LABEL: TEST: testEncodingAttrOnTensorType
 @run
 def testEncodingAttrOnTensorType():