[mlir][sparse] fixed doc formatting

[aartbik]

Summary

Indentation seems to have an impact on website layout.

[aartbik]

rebased

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

let description = [{
     support may consist of fully generated code or may be provided by
     means of a small sparse runtime support library.
 
     The concept of **treating sparsity as a property, not a tedious
     implementation detail**, by letting a **sparse compiler** generate
     sparse code automatically was pioneered for dense linear algebra by
     [Bik96] in MT1 (see https://www.aartbik.com/sparse.php) and formalized
     to tensor algebra by [Kjolstad17,Kjolstad20] in the Sparse Tensor
-    Algebra Compiler (TACO) project (see http://tensor-compiler.org/).
+    Algebra Compiler (TACO) project (see http://tensor-compiler.org).
 
     The MLIR implementation closely follows the "sparse iteration theory"
     that forms the foundation of TACO. A rewriting rule is applied to each
     tensor expression in the Linalg dialect (MLIR's tensor index notation)
     where the sparsity of tensors is indicated using the per-dimension level
     types dense/compressed together with a specification of the order on the
     dimensions (see [Chou18] for an in-depth discussions and possible
     extensions to these level types). Subsequently, a topologically sorted

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

def SparseTensor_NewOp : SparseTensor_Op<"new", []>,
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
 }
 
 def SparseTensor_ConvertOp : SparseTensor_Op<"convert", [SameOperandsAndResultType]>,
     Arguments<(ins AnyTensor:$source)>,
     Results<(outs AnyTensor:$dest)> {
   string summary = "Converts between different tensor types";
   string description = [{
-     Converts one sparse or dense tensor type to another tensor type. The rank
-     and dimensions of the source and destination types must match exactly,
-     only the sparse encoding of these types may be different. The name `convert`
-     was preferred over `cast`, since the operation may incur a non-trivial cost.
 
-     When converting between two different sparse tensor types, only explicitly
-     stored values are moved from one underlying sparse storage format to
-     the other. When converting from an unannotated dense tensor type to a
-     sparse tensor type, an explicit test for nonzero values is used. When
-     converting to an unannotated dense tensor type, implicit zeroes in the
-     sparse storage format are made explicit. Note that the conversions can have
-     non-trivial costs associated with them, since they may involve elaborate
-     data structure transformations. Also, conversions from sparse tensor types
-     into dense tensor types may be infeasible in terms of storage requirements.
 
     Examples:
 
     ```mlir
     %0 = sparse_tensor.convert %1 : tensor<32x32xf32> to tensor<32x32xf32, #CSR>
 
     %2 = sparse_tensor.convert %3 : tensor<8x8xi32, #CSC> to tensor<8x8xi32, #CSR>
     ```
 
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
 }
 
 def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor, Index:$dim)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extract pointers array at given dimension from a tensor";
   let description = [{
-     Returns the pointers array of the sparse storage scheme at the
-     given dimension for the given sparse tensor. This is similar to the
-     `memref.buffer_cast` operation in the sense that it provides a bridge
-     between a tensor world view and a bufferized world view. Unlike the
-     `memref.buffer_cast` operation, however, this sparse operation actually
-     lowers into a call into a support library to obtain access to the
-     pointers array.
 
-     Example:
 
     ```mlir
     %1 = sparse_tensor.pointers %0, %c1
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
       " `to` type($result)";
 }
 
 def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor, Index:$dim)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extract indices array at given dimension from a tensor";
   let description = [{
-     Returns the indices array of the sparse storage scheme at the
-     given dimension for the given sparse tensor. This is similar to the
-     `memref.buffer_cast` operation in the sense that it provides a bridge
-     between a tensor world view and a bufferized world view. Unlike the
-     `memref.buffer_cast` operation, however, this sparse operation actually
-     lowers into a call into a support library to obtain access to the
-     indices array.
 
-     Example:
 
     ```mlir
     %1 = sparse_tensor.indices %0, %c1
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor `,` $dim attr-dict `:` type($tensor)"
       " `to` type($result)";
 }
 
 def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
     Arguments<(ins AnyTensor:$tensor)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extract numerical values array from a tensor";
   let description = [{
-     Returns the values array of the sparse storage scheme for the given
-     sparse tensor, independent of the actual dimension. This is similar to
-     the `memref.buffer_cast` operation in the sense that it provides a bridge
-     between a tensor world view and a bufferized world view. Unlike the
-     `memref.buffer_cast` operation, however, this sparse operation actually
-     lowers into a call into a support library to obtain access to the
-     values array.
 
-     Example:
 
     ```mlir
     %1 = sparse_tensor.values %0 : tensor<64x64xf64, #CSR> to memref<?xf64>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
 }