[mlir][sparse] improve semi-ring doc

[aartbik]

Summary

Spell out SparseVector instead of just using SparseVec

[aartbik]

removed TABs

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

string description = [{
     is solely defined by side-effects and not SSA values. The semantics
     may be refined over time as our sparse abstractions evolve.
 
     Example:
 
     ```mlir
     sparse_tensor.compress %0, %1, %values, %filled, %added, %2
         : tensor<4x4xf64, #CSR>, memref<?xindex>, memref<?xf64>,
-    memref<?xi1>, memref<?xindex>, index
+          memref<?xi1>, memref<?xindex>, index
     ```
   }];
   let assemblyFormat = "$tensor `,` $indices `,` $values `,` $filled `,`"
-                        " $added `,` $count attr-dict `:` type($tensor) `,`"
-      " type($indices) `,` type($values) `,` type($filled) `,`"
-      " type($added) `,` type($count)";
+                       " type($indices) `,` type($values) `,` type($filled) `,`"
+                       " type($added) `,` type($count)";
 }
 
 def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
     Arguments<(ins AnySparseTensor:$tensor, UnitAttr:$hasInserts)>,
     Results<(outs AnyTensor:$result)> {
   let summary =
     "Rematerializes tensor from underlying sparse storage format";
   let description = [{
let description = [{
       would be equivalent to a union operation where non-overlapping values
       in the inputs are copied to the output unchanged.
 
       Example of isEqual applied to intersecting elements only:
 
       ```mlir
       %C = bufferization.alloc_tensor...
       %0 = linalg.generic #trait
-        ins(%A: tensor<?xf64, #SparseVec>, %B: tensor<?xf64, #SparseVec>)
-        outs(%C: tensor<?xi8, #SparseVec>) {
+        ins(%A: tensor<?xf64, #SparseVector>,
+            %B: tensor<?xf64, #SparseVector>)
+        outs(%C: tensor<?xi8, #SparseVector>) {
         ^bb0(%a: f64, %b: f64, %c: i8) :
           %result = sparse_tensor.binary %a, %b : f64, f64 to i8
             overlap={
               ^bb0(%arg0: f64, %arg1: f64):
                 %cmp = arith.cmpf "oeq", %arg0, %arg1 : f64
                 %ret_i8 = arith.extui %cmp : i1 to i8
                 sparse_tensor.yield %ret_i8 : i8
             }
             left={}
             right={}
           linalg.yield %result : i8
-      } -> tensor<?xi8, #SparseVec>
+      } -> tensor<?xi8, #SparseVector>
       ```
 
       Example of A+B in upper triangle, A-B in lower triangle:
 
       ```mlir
       %C = bufferization.alloc_tensor...
       %1 = linalg.generic #trait
         ins(%A: tensor<?x?xf64, #CSR>, %B: tensor<?x?xf64, #CSR>
let description = [{
       A region may also be declared empty (i.e. `absent={}`), indicating that the
       region does not contribute to the output.
 
       Example of A+1, restricted to existing elements:
 
       ```mlir
       %C = bufferization.alloc_tensor...
       %0 = linalg.generic #trait
-        ins(%A: tensor<?xf64, #SparseVec>)
-        outs(%C: tensor<?xf64, #SparseVec>) {
+         ins(%A: tensor<?xf64, #SparseVector>)
+        outs(%C: tensor<?xf64, #SparseVector>) {
         ^bb0(%a: f64, %c: f64) :
           %result = sparse_tensor.unary %a : f64 to f64
             present={
               ^bb0(%arg0: f64):
                 %cf1 = arith.constant 1.0 : f64
                 %ret = arith.addf %arg0, %cf1 : f64
                 sparse_tensor.yield %ret : f64
             }
             absent={}
           linalg.yield %result : f64
-      } -> tensor<?xf64, #SparseVec>
+      } -> tensor<?xf64, #SparseVector>
       ```
 
       Example returning +1 for existing values and -1 for missing values:
       ```mlir
       %result = sparse_tensor.unary %a : f64 to i32
         present={
           ^bb0(%x: f64):
             %ret = arith.constant 1 : i32
let description = [{
 
       Example of Matrix->Vector reduction using max(product(x_i), 100):
 
       ```mlir
       %cf1 = arith.constant 1.0 : f64
       %cf100 = arith.constant 100.0 : f64
       %C = bufferization.alloc_tensor...
       %0 = linalg.generic #trait
          ins(%A: tensor<?x?xf64, #SparseMatrix>)
-        outs(%C: tensor<?xf64, #SparseVec>) {
+        outs(%C: tensor<?xf64, #SparseVector>) {
         ^bb0(%a: f64, %c: f64) :
           %result = sparse_tensor.reduce %c, %a, %cf1 : f64 {
               ^bb0(%arg0: f64, %arg1: f64):
                 %0 = arith.mulf %arg0, %arg1 : f64
                 %cmp = arith.cmpf "ogt", %0, %cf100 : f64
                 %ret = arith.select %cmp, %cf100, %0 : f64
                 sparse_tensor.yield %ret : f64
             }
           linalg.yield %result : f64
-      } -> tensor<?xf64, #SparseVec>
+      } -> tensor<?xf64, #SparseVector>
       ```
   }];
 
   let regions = (region SizedRegion<1>:$region);
 
   let assemblyFormat = [{
          $x `,` $y `,` $identity attr-dict `:` type($output) $region
   }];