gh-40705: use the finer new categories for some lattice posets in library
    
namely declare some known properties as categories, as allowed by #39554

### 📝 Checklist

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

Author: Release Manager

src/sage/categories/finite_coxeter_groups.py

@@ -570,6 +570,7 @@ def m_cambrian_lattice(self, c, m=1, on_roots=False):
                 sage: CoxeterGroup(["A",2]).m_cambrian_lattice((1,2),2)
                 Finite lattice containing 12 elements
             """
+            from sage.categories.finite_lattice_posets import FiniteLatticePosets
             from sage.combinat.posets.lattices import LatticePoset
             if hasattr(c, "reduced_word"):
                 c = c.reduced_word()
@@ -627,7 +628,11 @@ def m_cambrian_lattice(self, c, m=1, on_roots=False):
                         if cov_element not in elements:
                             new.add(cov_element)
                         covers.append((new_element, cov_element))
-            return LatticePoset([elements, covers], cover_relations=True)
+            cat = FiniteLatticePosets()
+            if m == 1:
+                cat = cat.CongruenceUniform().Trim()
+            return LatticePoset([elements, covers], cover_relations=True,
+                                category=cat)
 
         def cambrian_lattice(self, c, on_roots=False):
             """

src/sage/combinat/nu_tamari_lattice.py

@@ -66,6 +66,7 @@
 #
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from sage.categories.finite_lattice_posets import FiniteLatticePosets
 from sage.combinat.nu_dyck_word import NuDyckWords, NuDyckWord
 from sage.combinat.posets.lattices import LatticePoset
 
@@ -111,7 +112,8 @@ def NuTamariLattice(nu):
             new_ndw = ndw.mutate(i)
             if new_ndw is not None:
                 covers.append([ndw, new_ndw])
-    return LatticePoset([elements, covers])
+    cat = FiniteLatticePosets().Trim().CongruenceUniform()
+    return LatticePoset([elements, covers], cover_relations=True, category=cat)
 
 
 def delta_swap(p, k, delta):
@@ -220,7 +222,7 @@ def AltNuTamariLattice(nu, delta=None):
         Finite lattice containing 7 elements
         sage: AltNuTamariLattice('01001') == AltNuTamariLattice('01001', [2, 0])
         True
-        sage: nu = '00100100101'; P = AltNuTamariLattice(nu); Q = NuTamariLattice(nu); P == Q
+        sage: nu = '00100100101'; P = AltNuTamariLattice(nu); Q = NuTamariLattice(nu); P.is_isomorphic(Q)
         True
 
     TESTS::

src/sage/combinat/posets/bubble_shuffle.py

@@ -16,6 +16,7 @@
 """
 from typing import Iterator
 
+from sage.categories.finite_lattice_posets import FiniteLatticePosets
 from sage.combinat.posets.lattices import LatticePoset
 from sage.combinat.subset import subsets
 from sage.combinat.shuffle import ShuffleProduct
@@ -169,7 +170,8 @@ def BubblePoset(m, n) -> LatticePoset:
 
     dg = DiGraph([(x, y) for x in bubbles for y in bubble_coverings(m, n, x)])
     # here we have more than just the cover relations
-    return LatticePoset(dg)
+    cat = FiniteLatticePosets().CongruenceUniform().Extremal()
+    return LatticePoset(dg, category=cat)
 
 
 def ShufflePoset(m, n) -> LatticePoset:

src/sage/combinat/posets/hochschild_lattice.py

@@ -18,6 +18,7 @@
 """
 from typing import Iterator
 
+from sage.categories.finite_lattice_posets import FiniteLatticePosets
 from sage.combinat.posets.lattices import LatticePoset
 from sage.graphs.digraph import DiGraph
 from sage.topology.simplicial_complex import SimplicialComplex
@@ -101,7 +102,8 @@ def cover_relations(a):
 
     dg = DiGraph({a: list(cover_relations(a)) for a in verts},
                  format="dict_of_lists")
-    return LatticePoset(dg.reverse(), cover_relations=True, check=False)
+    return LatticePoset(dg.reverse(), cover_relations=True, check=False,
+                        category=FiniteLatticePosets().CongruenceUniform())
 
 
 def hochschild_fan(n):

src/sage/combinat/posets/lattices.py

@@ -337,7 +337,7 @@ def atoms(self):
             return []
         return self.upper_covers(self.bottom())
 
-    def submeetsemilattice(self, elms):
+    def submeetsemilattice(self, elms, **kwds):
         r"""
         Return the smallest meet-subsemilattice containing elements on the given list.
 
@@ -377,9 +377,9 @@ def submeetsemilattice(self, elms):
                 gens_remaining.add(self.meet(x, g))
             current_set.add(g)
 
-        return MeetSemilattice(self.subposet(current_set))
+        return MeetSemilattice(self.subposet(current_set), **kwds)
 
-    def subjoinsemilattice(self, elms):
+    def subjoinsemilattice(self, elms, **kwds):
         r"""
         Return the smallest join-subsemilattice containing elements on the given list.
 
@@ -419,7 +419,7 @@ def subjoinsemilattice(self, elms):
                 gens_remaining.add(self.join(x, g))
             current_set.add(g)
 
-        return JoinSemilattice(self.subposet(current_set))
+        return JoinSemilattice(self.subposet(current_set), **kwds)
 
     def pseudocomplement(self, element):
         r"""
@@ -1125,6 +1125,9 @@ def is_stone(self, certificate=False) -> bool | tuple:
           ``(False, e)`` such that `e^* \vee e^{**} \neq \top`.
           If ``certificate=False`` return ``True`` or ``False``.
 
+        If the lattice is not distributive, the result is either
+        ``(False, None)`` or ``False``.
+
         EXAMPLES:
 
         Divisor lattices are canonical example::
@@ -1156,7 +1159,7 @@ def is_stone(self, certificate=False) -> bool | tuple:
         # is extended to directed, use that; see comment below.
 
         if not self.is_distributive():
-            raise ValueError("the lattice is not distributive")
+            return (False, None) if certificate else False
 
         from sage.arith.misc import factor
         ok = (True, None) if certificate else True
@@ -2346,7 +2349,8 @@ def skeleton(self):
             return self
         elms = [self._vertex_to_element(v) for v in
                 self._hasse_diagram.skeleton()]
-        return LatticePoset(self.subposet(elms))
+        return LatticePoset(self.subposet(elms),
+                            category=FiniteLatticePosets().Stone())
 
     def is_orthocomplemented(self, unique=False) -> bool:
         """
@@ -3234,7 +3238,7 @@ def is_vertically_decomposable(self, certificate=False) -> bool | tuple:
             return (True, self._vertex_to_element(e))
         return True
 
-    def sublattice(self, elms):
+    def sublattice(self, elms, **kwds):
         r"""
         Return the smallest sublattice containing elements on the given list.
 
@@ -3268,7 +3272,7 @@ def sublattice(self, elms):
                 gens_remaining.add(self.meet(x, g))
             current_set.add(g)
 
-        return LatticePoset(self.subposet(current_set))
+        return LatticePoset(self.subposet(current_set), **kwds)
 
     def is_sublattice(self, other) -> bool:
         """
@@ -3766,7 +3770,8 @@ def center(self):
         """
         neutrals = self.neutral_elements()
         comps = self.complements()
-        return self.sublattice([e for e in neutrals if e in comps])
+        return self.sublattice([e for e in neutrals if e in comps],
+                               category=FiniteLatticePosets().Stone())
 
     def is_dismantlable(self, certificate=False) -> bool | tuple:
         r"""

src/sage/combinat/posets/poset_examples.py

@@ -281,7 +281,7 @@ def BooleanLattice(n, facade=None, use_subsets=False):
                          for y in range(n) if v & (1 << y) == 0]
                      for v in range(2**n)})
         return FiniteLatticePoset(hasse_diagram=D,
-                                  category=FiniteLatticePosets(),
+                                  category=FiniteLatticePosets().Stone(),
                                   facade=facade)
 
     BubblePoset = staticmethod(bubble_shuffle.BubblePoset)
@@ -332,7 +332,7 @@ def ChainPoset(n, facade=None):
         D = DiGraph([range(n), [[x, x + 1] for x in range(n - 1)]],
                     format='vertices_and_edges')
         return FiniteLatticePoset(hasse_diagram=D,
-                                  category=FiniteLatticePosets(),
+                                  category=FiniteLatticePosets().Stone(),
                                   facade=facade)
 
     @staticmethod
@@ -413,7 +413,8 @@ def PentagonPoset(facade=None):
             sage: posets.DiamondPoset(5).is_distributive()
             False
         """
-        return LatticePoset([[1, 2], [4], [3], [4], []], facade=facade)
+        return LatticePoset([[1, 2], [4], [3], [4], []], facade=facade,
+                            category=FiniteLatticePosets().CongruenceUniform())
 
     @staticmethod
     def DiamondPoset(n, facade=None):
@@ -439,8 +440,10 @@ def DiamondPoset(n, facade=None):
         c[0] = list(range(1, n - 1))
         c[n - 1] = []
         D = DiGraph({v: c[v] for v in range(n)}, format='dict_of_lists')
-        return FiniteLatticePoset(hasse_diagram=D,
-                                  category=FiniteLatticePosets(),
+        cat = FiniteLatticePosets()
+        if n <= 4:
+            cat = cat.Stone()
+        return FiniteLatticePoset(hasse_diagram=D, category=cat,
                                   facade=facade)
 
     @staticmethod
@@ -777,7 +780,8 @@ def ProductOfChains(chain_lengths, facade=None):
 
         def compare(a, b):
             return all(x <= y for x, y in zip(a, b))
-        return LatticePoset([elements, compare], facade=facade)
+        return LatticePoset([elements, compare], facade=facade,
+                            category=FiniteLatticePosets().Distributive())
 
     @staticmethod
     def RandomPoset(n, p):
@@ -1639,7 +1643,7 @@ def DoubleTailedDiamond(n):
         edges.extend([(n, n + 1), (n, n + 2), (n + 1, n + 3), (n + 2, n + 3)])
         edges.extend((i, i + 1) for i in range(n + 3, 2 * n + 2))
         p = DiGraph([list(range(1, 2 * n + 3)), edges])
-        return DCompletePoset(p)
+        return DCompletePoset(p, category=FiniteLatticePosets().Distributive())
 
     @staticmethod
     def PermutationPattern(n):