switch to ChainGraded

Author: fchapoton

src/sage/categories/category_with_axiom.py

@@ -1690,7 +1690,7 @@ class ``Sets.Finite``), or in a separate file (typically in a class
                "Inverse", "Unital", "Division", "NoZeroDivisors", "Cellular",
                "AdditiveCommutative", "AdditiveAssociative", "AdditiveInverse", "AdditiveUnital",
                "Extremal", "Trim", "Semidistributive", "CongruenceUniform",
-               "Graded", "Distributive", "Stone",
+               "ChainGraded", "Distributive", "Stone",
                "Endset",
                "Pointed",
                "Stratified"

src/sage/categories/finite_complex_reflection_groups.py

@@ -976,7 +976,7 @@ def noncrossing_partition_lattice(self, c=None, L=None,
                 P = Poset(([], rels), cover_relations=True, facade=True)
                 if P.is_lattice():
                     P = LatticePoset(P,
-                                     category=FiniteLatticePosets().Graded())
+                                     category=FiniteLatticePosets().ChainGraded())
                 return P
 
             def generalized_noncrossing_partitions(self, m, c=None, positive=False):

src/sage/categories/finite_coxeter_groups.py

@@ -483,7 +483,7 @@ def weak_poset(self, side='right', facade=False):
                 return Poset((self, covers), cover_relations=True,
                              facade=facade)
             covers = tuple([u, v] for u in self for v in u.upper_covers(side=side))
-            cat = FiniteLatticePosets().Graded()
+            cat = FiniteLatticePosets().ChainGraded()
             return LatticePoset((self, covers), cover_relations=True,
                                 facade=facade, category=cat)
 

src/sage/categories/lattice_posets.py

@@ -90,17 +90,17 @@ def join(self, x, y):
             """
 
     class SubcategoryMethods:
-        def Graded(self):
+        def ChainGraded(self):
             r"""
             A lattice is graded if all maximal chains have the same length.
 
             EXAMPLES::
 
                 sage: P = posets.DivisorLattice(24)
-                sage: P in FiniteLatticePosets().Graded()
+                sage: P in FiniteLatticePosets().ChainGraded()
                 True
             """
-            return self._with_axiom("Graded")
+            return self._with_axiom("ChainGraded")
 
         def Stone(self):
             r"""
@@ -261,13 +261,13 @@ def extra_super_categories(self):
             return [LatticePosets().Extremal()]
 
         class SubcategoryMethods:
-            def Graded(self):
+            def ChainGraded(self):
                 r"""
                 A trim and graded lattice is distributive.
 
                 EXAMPLES::
 
-                    sage: FiniteLatticePosets().Trim().Graded()
+                    sage: FiniteLatticePosets().Trim().ChainGraded()
                     Category of finite distributive lattice posets
                 """
                 return self._with_axiom("Distributive")
@@ -376,7 +376,7 @@ def extra_super_categories(self):
             """
             return [LatticePosets().Trim(),
                     LatticePosets().CongruenceUniform(),
-                    LatticePosets().Graded()]
+                    LatticePosets().ChainGraded()]
 
         class ParentMethods:
             def is_distributive(self):
@@ -431,21 +431,21 @@ def is_stone(self):
                 """
                 return True
 
-    class Graded(CategoryWithAxiom):
+    class ChainGraded(CategoryWithAxiom):
         """
         The category of graded lattices.
 
         EXAMPLES::
 
-            sage: cat = FiniteLatticePosets().Graded(); cat
-            Category of finite graded lattice posets
+            sage: cat = FiniteLatticePosets().ChainGraded(); cat
+            Category of finite chain graded lattice posets
 
             sage: cat.super_categories()
             [Category of finite lattice posets,
-             Category of graded lattice posets]
+             Category of chain graded lattice posets]
         """
         class ParentMethods:
-            def is_graded(self):
+            def is_graded(self) -> bool:
                 """
                 Return whether ``self`` is a graded lattice.
 

src/sage/combinat/posets/bubble_shuffle.py

@@ -201,7 +201,7 @@ def ShufflePoset(m, n) -> LatticePoset:
     dg = DiGraph([(x, y) for x in bubbles
                   for y in bubble_coverings(m, n, x, transpose=False)])
     # here we just have the cover relations
-    cat = FiniteLatticePosets().Graded()
+    cat = FiniteLatticePosets().ChainGraded()
     return LatticePoset(dg, cover_relations=True, check=False, category=cat)
 
 

src/sage/combinat/posets/poset_examples.py

@@ -440,7 +440,7 @@ 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')
-        cat = FiniteLatticePosets().Graded()
+        cat = FiniteLatticePosets().ChainGraded()
         if n <= 4:
             cat = cat.Stone()
         return FiniteLatticePoset(hasse_diagram=D, category=cat,
@@ -1211,7 +1211,7 @@ def weak_covers(s):
         return LatticePoset(
             {s: weak_covers(s) for s in Permutations(n)},
             element_labels, check=False,
-            category=FiniteLatticePosets().Graded().Semidistributive()
+            category=FiniteLatticePosets().ChainGraded().Semidistributive()
         )
 
     @staticmethod