[mlir][sparse] fixed typos

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

let description = [{
     order. Each iteration lattice point consists of a conjunction of tensor
     indices together with a tensor (sub)expression that needs to be evaluated
     for that conjunction.  Within the lattice, iteration points are ordered
     according to the way indices are exhausted. As such these iteration
     lattices drive actual sparse code generation, which consists of a
     relatively straightforward one-to-one mapping from iteration lattices
     to combinations of for-loops, while-loops, and if-statements. Sparse
     tensor outputs that materialize uninitialized are handled with
-    insertions in pure lexicograph index order if all parallel loops
+    insertions in pure lexicographical index order if all parallel loops
     are outermost or using a 1-dimensional access pattern expansion
     (a.k.a. workspace) where feasible [Gustavson72,Bik96,Kjolstad19].
 
     * [Bik96] Aart J.C. Bik. Compiler Support for Sparse Matrix Computations.
     PhD thesis, Leiden University, May 1996.
     * [Chou18] Stephen Chou, Fredrik Berg Kjolstad, and Saman Amarasinghe.
     Format Abstraction for Sparse Tensor Algebra Compilers. Proceedings of
     the ACM on Programming Languages, October 2018.

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

 // the code generator and the support library. The semantics of these operations
 // may be refined over time as our sparse abstractions evolve.
 //===----------------------------------------------------------------------===//
 
 def SparseTensor_LexInsertOp : SparseTensor_Op<"lex_insert", []>,
     Arguments<(ins AnyTensor:$tensor,
                StridedMemRefRankOf<[Index], [1]>:$indices,
                AnyType:$value)> {
-  string summary = "Inserts a value into given sparse tensor in lexicograph index order";
+  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 lexicographic
+    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.
 
     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