gh-39578: adding some type annotations in lattices
    
mostly in the many methods with a boolean result

### 📝 Checklist

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

Author: Release Manager

Diff for: src/sage/combinat/posets/lattices.py

@@ -916,7 +916,7 @@ def neutral_elements(self):
         t = sorted(self._hasse_diagram.neutral_elements())
         return [self._vertex_to_element(v) for v in t]
 
-    def is_join_distributive(self, certificate=False):
+    def is_join_distributive(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is join-distributive and ``False``
         otherwise.
@@ -1005,7 +1005,7 @@ def is_join_distributive(self, certificate=False):
         diamond = next(self._hasse_diagram.subgraph_search_iterator(M3, return_graphs=False))
         return (False, self[diamond[0]])
 
-    def is_meet_distributive(self, certificate=False):
+    def is_meet_distributive(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is meet-distributive and ``False``
         otherwise.
@@ -1093,7 +1093,7 @@ def is_meet_distributive(self, certificate=False):
         diamond = next(self._hasse_diagram.subgraph_search_iterator(M3, return_graphs=False))
         return (False, self[diamond[4]])
 
-    def is_stone(self, certificate=False):
+    def is_stone(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is a Stone lattice, and ``False``
         otherwise.
@@ -1188,7 +1188,7 @@ def is_stone(self, certificate=False):
 
         return ok
 
-    def is_distributive(self, certificate=False):
+    def is_distributive(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is distributive, and ``False``
         otherwise.
@@ -1228,7 +1228,7 @@ def is_distributive(self, certificate=False):
               :meth:`is_semidistributive`, :meth:`is_join_distributive`,
               :meth:`is_meet_distributive`, :meth:`is_subdirectly_reducible`,
               :meth:`is_trim`,
-              :meth:`is_constructible_by_doublings` (by interval doubling),
+              :meth:`is_congruence_uniform`,
               :meth:`is_extremal`
 
             - Stronger properties: :meth:`is_stone`
@@ -1262,7 +1262,7 @@ def is_distributive(self, certificate=False):
                         self._vertex_to_element(diamond[2]),
                         self._vertex_to_element(diamond[3])))
 
-    def is_semidistributive(self):
+    def is_semidistributive(self) -> bool:
         """
         Return ``True`` if the lattice is both join- and meet-semidistributive,
         and ``False`` otherwise.
@@ -1308,7 +1308,7 @@ def is_semidistributive(self):
                  H.out_degree_sequence().count(1)) and
                 self.is_meet_semidistributive())
 
-    def is_meet_semidistributive(self, certificate=False):
+    def is_meet_semidistributive(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is meet-semidistributive, and ``False``
         otherwise.
@@ -1400,7 +1400,7 @@ def is_meet_semidistributive(self, certificate=False):
             return (True, None)
         return True
 
-    def is_join_semidistributive(self, certificate=False):
+    def is_join_semidistributive(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is join-semidistributive, and ``False``
         otherwise.
@@ -1496,7 +1496,7 @@ def is_join_semidistributive(self, certificate=False):
         return all(H.kappa_dual(v) is not None
                    for v in H if H.out_degree(v) == 1)
 
-    def is_extremal(self):
+    def is_extremal(self) -> bool:
         """
         Return ``True`` if the lattice is extremal, and ``False``
         otherwise.
@@ -1526,7 +1526,7 @@ def is_extremal(self):
         mi = len(self.meet_irreducibles())
         return ji == mi == self.height() - 1
 
-    def is_trim(self, certificate=False):
+    def is_trim(self, certificate=False) -> bool | tuple:
         """
         Return whether a lattice is trim.
 
@@ -1575,7 +1575,7 @@ def is_trim(self, certificate=False):
         else:
             return (False, None) if certificate else False
 
-    def is_complemented(self, certificate=False):
+    def is_complemented(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is complemented, and
         ``False`` otherwise.
@@ -1626,7 +1626,7 @@ def is_complemented(self, certificate=False):
             return (True, None)
         return (False, self._vertex_to_element(e))
 
-    def is_cosectionally_complemented(self, certificate=False):
+    def is_cosectionally_complemented(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is cosectionally complemented, and
         ``False`` otherwise.
@@ -1702,7 +1702,7 @@ def is_cosectionally_complemented(self, certificate=False):
                 return False
         return (True, None) if certificate else True
 
-    def is_relatively_complemented(self, certificate=False):
+    def is_relatively_complemented(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is relatively complemented, and
         ``False`` otherwise.
@@ -1815,7 +1815,7 @@ def is_relatively_complemented(self, certificate=False):
                                     self._vertex_to_element(e3)))
         return (True, None) if certificate else True
 
-    def is_sectionally_complemented(self, certificate=False):
+    def is_sectionally_complemented(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is sectionally complemented, and
         ``False`` otherwise.
@@ -2086,7 +2086,7 @@ def complements(self, element=None):
                 if self.meet(x, element) == self.bottom() and
                 self.join(x, element) == self.top()]
 
-    def is_pseudocomplemented(self, certificate=False):
+    def is_pseudocomplemented(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is pseudocomplemented, and ``False``
         otherwise.
@@ -2153,7 +2153,7 @@ def is_pseudocomplemented(self, certificate=False):
             return (True, None)
         return True
 
-    def is_join_pseudocomplemented(self, certificate=False):
+    def is_join_pseudocomplemented(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is join-pseudocomplemented, and
         ``False`` otherwise.
@@ -2323,7 +2323,7 @@ def is_orthocomplemented(self, unique=False):
             return True
         raise AssertionError("bug in is_orthocomplemented()")
 
-    def is_atomic(self, certificate=False):
+    def is_atomic(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is atomic, and ``False`` otherwise.
 
@@ -2381,7 +2381,7 @@ def is_atomic(self, certificate=False):
                 return (False, self._vertex_to_element(v))
         return (True, None)
 
-    def is_coatomic(self, certificate=False):
+    def is_coatomic(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is coatomic, and ``False`` otherwise.
 
@@ -2439,7 +2439,7 @@ def is_coatomic(self, certificate=False):
                 return (False, self._vertex_to_element(v))
         return (True, None)
 
-    def is_geometric(self):
+    def is_geometric(self) -> bool:
         """
         Return ``True`` if the lattice is geometric, and ``False`` otherwise.
 
@@ -2484,7 +2484,7 @@ def is_geometric(self):
         """
         return self.is_atomic() and self.is_upper_semimodular()
 
-    def is_planar(self):
+    def is_planar(self) -> bool:
         r"""
         Return ``True`` if the lattice is *upward* planar, and ``False``
         otherwise.
@@ -2549,7 +2549,7 @@ def is_planar(self):
         g.add_edge(0, self.cardinality() - 1)
         return g.is_planar()
 
-    def is_modular(self, L=None, certificate=False):
+    def is_modular(self, L=None, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is modular and ``False`` otherwise.
 
@@ -2654,7 +2654,7 @@ def is_modular(self, L=None, certificate=False):
             return (True, None)
         return True
 
-    def is_modular_element(self, x):
+    def is_modular_element(self, x) -> bool:
         r"""
         Return ``True`` if ``x`` is a modular element and ``False`` otherwise.
 
@@ -2686,7 +2686,7 @@ def is_modular_element(self, x):
         """
         return self.is_modular([x])
 
-    def is_left_modular_element(self, x):
+    def is_left_modular_element(self, x) -> bool:
         r"""
         Return ``True`` if ``x`` is a left modular element
         and ``False`` otherwise.
@@ -2719,7 +2719,7 @@ def is_left_modular_element(self, x):
                    self.join(y, self.meet(x, z))
                    for y, z in self.cover_relations_iterator())
 
-    def is_upper_semimodular(self, certificate=False):
+    def is_upper_semimodular(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is upper semimodular and
         ``False`` otherwise.
@@ -2779,7 +2779,7 @@ def is_upper_semimodular(self, certificate=False):
                             self._vertex_to_element(nonmodular[1])))
         return False
 
-    def is_lower_semimodular(self, certificate=False):
+    def is_lower_semimodular(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is lower semimodular and
         ``False`` otherwise.
@@ -2834,7 +2834,7 @@ def is_lower_semimodular(self, certificate=False):
                             self._vertex_to_element(nonmodular[1])))
         return False
 
-    def is_supersolvable(self, certificate=False):
+    def is_supersolvable(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is supersolvable, and
         ``False`` otherwise.
@@ -3091,7 +3091,7 @@ def vertical_decomposition(self, elements_only=False):
                                                            elms[i + 1] + 1)]))
                 for i in range(n - 1)]
 
-    def is_vertically_decomposable(self, certificate=False):
+    def is_vertically_decomposable(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is vertically decomposable, and
         ``False`` otherwise.
@@ -3185,7 +3185,7 @@ def sublattice(self, elms):
 
         return LatticePoset(self.subposet(current_set))
 
-    def is_sublattice(self, other):
+    def is_sublattice(self, other) -> bool:
         """
         Return ``True`` if the lattice is a sublattice of ``other``,
         and ``False`` otherwise.
@@ -3683,7 +3683,7 @@ def center(self):
         comps = self.complements()
         return self.sublattice([e for e in neutrals if e in comps])
 
-    def is_dismantlable(self, certificate=False):
+    def is_dismantlable(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is dismantlable, and ``False``
         otherwise.
@@ -3798,7 +3798,7 @@ def is_dismantlable(self, certificate=False):
             return True
         return (True, [self[e] for e in cert])
 
-    def is_interval_dismantlable(self, certificate=False):
+    def is_interval_dismantlable(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is interval dismantlable, and
         ``False`` otherwise.
@@ -3911,7 +3911,7 @@ def recursive_is_interval_dismantlable(self):
             return result if certificate else True
         return (False, minimal_non_int_dismant(self)) if certificate else False
 
-    def is_sublattice_dismantlable(self):
+    def is_sublattice_dismantlable(self) -> bool:
         """
         Return ``True`` if the lattice is sublattice dismantlable, and
         ``False`` otherwise.
@@ -3984,7 +3984,7 @@ def is_sublattice_dismantlable(self):
 
         return False
 
-    def is_subdirectly_reducible(self, certificate=False):
+    def is_subdirectly_reducible(self, certificate=False) -> bool | tuple:
         r"""
         Return ``True`` if the lattice is subdirectly reducible.
 
@@ -4367,7 +4367,7 @@ def is_congruence_uniform(self) -> bool:
         """
         return self.is_constructible_by_doublings(type="interval")
 
-    def is_isoform(self, certificate=False):
+    def is_isoform(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is isoform and ``False`` otherwise.
 
@@ -4442,7 +4442,7 @@ def is_isoform(self, certificate=False):
                     return False
         return ok
 
-    def is_uniform(self, certificate=False):
+    def is_uniform(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is uniform and ``False`` otherwise.
 
@@ -4522,7 +4522,7 @@ def is_uniform(self, certificate=False):
                     return False
         return ok
 
-    def is_regular(self, certificate=False):
+    def is_regular(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is regular and ``False`` otherwise.
 
@@ -4590,7 +4590,7 @@ def is_regular(self, certificate=False):
                     return False
         return ok
 
-    def is_simple(self, certificate=False):
+    def is_simple(self, certificate=False) -> bool | tuple:
         """
         Return ``True`` if the lattice is simple and ``False`` otherwise.