gh-40123: adding typing annotations on many has_* methods
    
so that we know they return bool

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: #40123
Reported by: Frédéric Chapoton
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/algebras/affine_nil_temperley_lieb.py

@@ -212,7 +212,7 @@ def product_on_basis(self, w, w1):
         return self.monomial(w)
 
     @cached_method
-    def has_no_braid_relation(self, w, i):
+    def has_no_braid_relation(self, w, i) -> bool:
         """
         Assuming that `w` contains no relations of the form `s_i^2` or `s_i s_{i+1} s_i` or
         `s_i s_{i-1} s_i`, tests whether `w s_i` contains terms of this form.
@@ -239,10 +239,7 @@ def has_no_braid_relation(self, w, i):
                     (i + 1) % w.parent().n]
         for j in adjacent:
             if j in w.descents():
-                if j in wi.descents():
-                    return False
-                else:
-                    return True
+                return j not in wi.descents()
         return self.has_no_braid_relation(w * s[w.first_descent()], i)
 
     def _repr_term(self, t, short_display=True):

src/sage/categories/algebras.py

@@ -159,7 +159,7 @@ def characteristic(self):
             """
             return self.base_ring().characteristic()
 
-        def has_standard_involution(self):
+        def has_standard_involution(self) -> bool:
             r"""
             Return ``True`` if the algebra has a standard involution and ``False`` otherwise.
 

src/sage/categories/coxeter_groups.py

@@ -1427,7 +1427,7 @@ def _test_coxeter_relations(self, **options):
                         tester.assertNotEqual(l**p, one, "unexpected relation")
 
     class ElementMethods:
-        def has_descent(self, i, side='right', positive=False):
+        def has_descent(self, i, side='right', positive=False) -> bool:
             """
             Return whether `i` is a (left/right) descent of ``self``.
 
@@ -1459,7 +1459,7 @@ def has_descent(self, i, side='right', positive=False):
             return self.has_left_descent(i) != positive
 
 #        @abstract_method(optional = True)
-        def has_right_descent(self, i):
+        def has_right_descent(self, i) -> bool:
             """
             Return whether `i` is a right descent of ``self``.
 
@@ -1478,7 +1478,7 @@ def has_right_descent(self, i):
             """
             return (~self).has_left_descent(i)
 
-        def has_left_descent(self, i):
+        def has_left_descent(self, i) -> bool:
             """
             Return whether `i` is a left descent of ``self``.
 
@@ -1820,7 +1820,7 @@ def support(self):
             """
             return set(self.reduced_word())
 
-        def has_full_support(self):
+        def has_full_support(self) -> bool:
             r"""
             Return whether ``self`` has full support.
 

src/sage/categories/examples/finite_coxeter_groups.py

@@ -185,7 +185,7 @@ class Element(ElementWrapper):
         wrapped_class = tuple
         __lt__ = ElementWrapper._lt_by_value
 
-        def has_right_descent(self, i, positive=False, side='right'):
+        def has_right_descent(self, i, positive=False, side='right') -> bool:
             r"""
             Implement :meth:`SemiGroups.ElementMethods.has_right_descent`.
 

src/sage/categories/examples/finite_weyl_groups.py

@@ -173,7 +173,7 @@ def degrees(self):
 
     class Element(ElementWrapper):
 
-        def has_right_descent(self, i):
+        def has_right_descent(self, i) -> bool:
             """
             Implement :meth:`CoxeterGroups.ElementMethods.has_right_descent`.
 
@@ -185,7 +185,7 @@ def has_right_descent(self, i):
                 True
                 sage: S._test_has_descent()
             """
-            return (self.value[i] > self.value[i+1])
+            return (self.value[i] > self.value[i + 1])
 
 
 Example = SymmetricGroup

src/sage/combinat/colored_permutations.py

@@ -276,7 +276,7 @@ def to_matrix(self):
         D = diagonal_matrix(Cp, [g ** i for i in self._colors])
         return self._perm.to_matrix() * D
 
-    def has_left_descent(self, i):
+    def has_left_descent(self, i) -> bool:
         r"""
         Return ``True`` if ``i`` is a left descent of ``self``.
 
@@ -1431,7 +1431,7 @@ def to_matrix(self):
         """
         return self._perm.to_matrix() * diagonal_matrix(self._colors)
 
-    def has_left_descent(self, i):
+    def has_left_descent(self, i) -> bool:
         """
         Return ``True`` if ``i`` is a left descent of ``self``.
 

src/sage/combinat/fully_commutative_elements.py

@@ -373,12 +373,12 @@ def find_descent(self, s, side='left'):
         """
         m = self.parent().coxeter_group().coxeter_matrix()
         view = list(self) if side == 'left' else self[::-1]
-        for (i, t) in enumerate(view):
+        for i, t in enumerate(view):
             if t == s and not any(m[x, t] > 2 for x in view[:i]):
                 return i
         return None
 
-    def has_descent(self, s, side='left'):
+    def has_descent(self, s, side='left') -> bool:
         r"""
         Determine if ``s`` is a descent on the appropriate side of ``self``.
 

src/sage/combinat/permutation.py

@@ -7860,7 +7860,7 @@ def reflection(self, i):
         return self.element_class(self, data, check=False)
 
     class Element(Permutation):
-        def has_left_descent(self, i):
+        def has_left_descent(self, i) -> bool:
             r"""
             Check if ``i`` is a left descent of ``self``.
 
@@ -7898,7 +7898,7 @@ def has_left_descent(self, i):
                 if val == i + 1:
                     return True
 
-        def has_right_descent(self, i, mult=None):
+        def has_right_descent(self, i, mult=None) -> bool:
             r"""
             Check if ``i`` is a right descent of ``self``.
 

src/sage/combinat/posets/posets.py

@@ -3123,7 +3123,7 @@ def bottom(self):
             return None
         return self._vertex_to_element(hasse_bot)
 
-    def has_bottom(self):
+    def has_bottom(self) -> bool:
         """
         Return ``True`` if the poset has a unique minimal element, and
         ``False`` otherwise.
@@ -3178,7 +3178,7 @@ def top(self):
             return None
         return self._vertex_to_element(hasse_top)
 
-    def has_top(self):
+    def has_top(self) -> bool:
         """
         Return ``True`` if the poset has a unique maximal element, and
         ``False`` otherwise.

src/sage/combinat/root_system/root_lattice_realizations.py

@@ -3642,7 +3642,7 @@ def reflection(self, root, use_coroot=False):
         # Descents
         ##########################################################################
 
-        def has_descent(self, i, positive=False):
+        def has_descent(self, i, positive=False) -> bool:
             """
             Test if ``self`` has a descent at position `i`, that is, if ``self`` is
             on the strict negative side of the `i`-th simple reflection