Clarify documentation for `Elementwise`, `Scalarizable`, `Vectorizable`, and `Tensorizable` traits.

mlir/include/mlir/IR/OpDefinition.h

 // values of `MemRef` type where those references can be 'normalized'.
 // TODO: Right now, the operands of an operation are either all normalizable,
 // or not. In the future, we may want to allow some of the operands to be
 // normalizable.
 template <typename ConcrentType>
 struct MemRefsNormalizable
     : public TraitBase<ConcrentType, MemRefsNormalizable> {};
 
-/// This trait tags element-wise ops that operate on scalars, vectors, or
-/// tensors.
+/// This trait tags element-wise ops on vectors or tensors.
 ///
 /// NOTE: Not all ops that are "elementwise" in some abstract sense satisfy this
 /// trait. In particular, broadcasting behavior is not allowed.
 ///
 /// An `Elementwise` op must satisfy the following properties:
 ///
 /// 1. If any result is a vector/tensor then at least one operand must also be a
 ///    vector/tensor.
struct Elementwise : public TraitBase<ConcreteType, Elementwise> {
   static LogicalResult verifyTrait(Operation *op) {
     return ::mlir::OpTrait::impl::verifyElementwise(op);
   }
 };
 
 /// This trait tags `Elementwise` operatons that can be systematically
 /// scalarized. All vector/tensor operands and results are then replaced by
 /// scalars of the respective element type. Semantically, this is the operation
-/// on a single element per vector/tensor.
+/// on a single element of the vector/tensor.
 ///
 /// Rationale:
 /// Allow to define the vector/tensor semantics of elementwise operations based
-/// on scalars. This provides a constructive procedure for IR transformations
-/// to, e.g., create scalar loop bodies from tensor ops.
+/// on the same op's behavior on scalars. This provides a constructive procedure
+/// for IR transformations to, e.g., create scalar loop bodies from tensor ops.
 ///
 /// Example:
 /// ```
 /// %tensor_select = "std.select"(%pred_tensor, %true_val, %false_val)
 ///                      : (tensor<?xi1>, tensor<?xf32>, tensor<?xf32>)
 ///                      -> tensor<?xf32>
 /// ```
 /// can be scalarized to
static_assert(
         "`Scalarizable` trait is only applicable to `Elementwise` ops.");
     return success();
   }
 };
 
 /// This trait tags `Elementwise` operatons that can be systematically
 /// vectorized. All scalar operands and results are then replaced by vectors
 /// with the respective element type. Semantically, this is the operation on
-/// multiple arguments simultaneously.
+/// multiple elements simultaneously. See also `Tensorizable`.
 ///
 /// Rationale:
 /// Provide the reverse to `Scalarizable` which, when chained together, allows
 /// reasoning about the relationship between the tensor and vector case.
 /// Additionally, it permits reasoning about promoting scalars to vectors via
-/// broadcasting in cases like `%select_scalar_pred` above.
+/// broadcasting in cases like `%select_scalar_pred` below.
 template <typename ConcreteType>
 struct Vectorizable : public TraitBase<ConcreteType, Vectorizable> {
   static LogicalResult verifyTrait(Operation *op) {
     static_assert(
         ConcreteType::template hasTrait<Elementwise>(),
         "`Vectorizable` trait is only applicable to `Elementwise` ops.");
     return success();
   }
 };
 
 /// This trait tags `Elementwise` operatons that can be systematically
 /// tensorized. All scalar operands and results are then replaced by tensors
 /// with the respective element type. Semantically, this is the operation on
-/// multiple arguments simultaneously.
+/// multiple elements simultaneously. See also `Vectorizable`.
 ///
 /// Rationale:
 /// Provide the reverse to `Scalarizable` which, when chained together, allows
 /// reasoning about the relationship between the tensor and vector case.
 /// Additionally, it permits reasoning about promoting scalars to tensors via
-/// broadcasting in cases like `%select_scalar_pred` above.
+/// broadcasting in cases like `%select_scalar_pred` below.
 ///
 /// Examples:
 /// ```
 /// %scalar = "std.addf"(%a, %b) : (f32, f32) -> f32
 /// ```
 /// can be tensorized to
 /// ```
 /// %tensor = "std.addf"(%a, %b) : (tensor<?xf32>, tensor<?xf32>)
-///               -> tensor<?xf32>)
+///               -> tensor<?xf32>
 /// ```
 ///
 /// ```
 /// %scalar_pred = "std.select"(%pred, %true_val, %false_val)
 ///                    : (i1, tensor<?xf32>, tensor<?xf32>) -> tensor<?xf32>
 /// ```
 /// can be tensorized to
 /// ```