[mlir][sparse] updated our sparse dialect doc with some recent changes

[aartbik]

Summary

The init and tensor ops are renamed (and one moved to another dialect).

[aartbik]

fixed another issue in doc

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

def SparseTensor_LexInsertOp : SparseTensor_Op<"lex_insert", []>,
     Arguments<(ins AnySparseTensor:$tensor,
                StridedMemRefRankOf<[Index], [1]>:$indices,
                AnyType:$value)> {
   string summary = "Inserts a value into given sparse tensor in lexicographical index order";
   string description = [{
     Inserts the given value at given indices into the underlying sparse
     storage format of the given tensor with the given indices. This
     operation can only be applied when a tensor materializes unintialized
-    with an `init` operation, the insertions occur in strict lexicographical
-    index order, and the final tensor is constructed with a `tensor`
-    operation that has the `hasInserts` attribute set.
+    with a `bufferization.alloc_tensor` operation, the insertions occur in
+    strict lexicographical index order, and the final tensor is constructed
+    with a `load` operation that has the `hasInserts` attribute set.
 
     Note that this operation is "impure" in the sense that its behavior
     is solely defined by side-effects and not SSA values. The semantics
     may be refined over time as our sparse abstractions evolve.
 
     ```mlir
     sparse_tensor.lex_insert %tensor, %indices, %val
       : tensor<1024x1024xf64, #CSR>, memref<?xindex>, f64
def SparseTensor_LoadOp : SparseTensor_Op<"load", [SameOperandsAndResultType]>,
   let assemblyFormat = "$tensor (`hasInserts` $hasInserts^)? attr-dict `:` type($tensor)";
 }
 
 def SparseTensor_ReleaseOp : SparseTensor_Op<"release", []>,
     Arguments<(ins AnySparseTensor:$tensor)> {
   string summary = "Releases underlying sparse storage format of given tensor";
   string description = [{
     Releases the underlying sparse storage format for a tensor that
-    materialized earlier through a `new` operator, `init` operator, or a
-    `convert` operator with an annotated tensor type as destination (unless
-    that convert is folded away since the source and destination types were
-    identical). This operation should only be called once for any materialized
-    tensor.  Also, after this operation, any subsequent `memref` querying
-    operation on the tensor returns undefined results.
+    materialized earlier through a `new` operation, a `convert` operation
+    with annotated destination tensor type (unless the convert is folded
+    away), or a `bufferization.alloc_tensor` operation. The release operation
+    should only be called once for any materialized tensor. After this
+    operation, any subsequent `memref` querying operation on the tensor
+    returns undefined results.
 
     Note that this operation is "impure" in the sense that its behavior
     is solely defined by side-effects and not SSA values. The semantics
     may be refined over time as our sparse abstractions evolve.
 
     Example:
 
     ```mlir
let description = [{
         ins(%A: tensor<?x?xf64, #CSR>, %B: tensor<?x?xf64, #CSR>
         outs(%C: tensor<?x?xf64, #CSR> {
         ^bb0(%a: f64, %b: f64, %c: f64) :
           %row = linalg.index 0 : index
           %col = linalg.index 1 : index
           %result = sparse_tensor.binary %a, %b : f64, f64 to f64
             overlap={
               ^bb0(%x: f64, %y: f64):
-                %cmp = arith.cmpi "uge", %column, %row : index
+                %cmp = arith.cmpi "uge", %col, %row : index
                 %upperTriangleResult = arith.addf %x, %y : f64
                 %lowerTriangleResult = arith.subf %x, %y : f64
                 %ret = arith.select %cmp, %upperTriangleResult, %lowerTriangleResult : f64
                 sparse_tensor.yield %ret : f64
             }
             left=identity
             right={
               ^bb0(%y: f64):
-                %cmp = arith.cmpi "uge", %column, %row : index
+                %cmp = arith.cmpi "uge", %col, %row : index
                 %lowerTriangleResult = arith.negf %y : f64
-                %ret = arith.select %cmp, %y, %lowerTriangleResult
+                %ret = arith.select %cmp, %y, %lowerTriangleResult : f64
                 sparse_tensor.yield %ret : f64
             }
           linalg.yield %result : f64
       } -> tensor<?x?xf64, #CSR>
       ```
 
       Example of set difference. Returns a copy of A where its sparse structure
       is *not* overlapped by B. The element type of B can be different than A