passagemath-combinat 10.6.1__cp312-cp312-musllinux_1_2_aarch64.whl → 10.8.1a1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/combinat/multiset_partition_into_sets_ordered.py

@@ -1043,7 +1043,7 @@ class OrderedMultisetPartitionIntoSets(ClonableArray,
         w = []
         v = [0]
         for eblock in ew:
-            for (i,wj) in sorted(eblock, reverse=True):
+            for i, wj in sorted(eblock, reverse=True):
                 vj = v[-1]
                 if i == 0:
                     vj += 1
@@ -1561,7 +1561,7 @@ class OrderedMultisetPartitionsIntoSets(UniqueRepresentation, Parent):
 
         # pop keys with empty values, with the exception of 'size' or 'order'
         self.constraints = {}
-        for (key,val) in constraints.items():
+        for key, val in constraints.items():
             if val:
                 self.constraints[key] = val
             elif key in ("size", "order", "length") and val is not None:
@@ -1954,7 +1954,8 @@ class OrderedMultisetPartitionsIntoSets(UniqueRepresentation, Parent):
 
         # slice by 'order'
         if "alphabet" in fc:
-            no_alpha = {k: v for (k, v) in self.constraints.items() if k != "alphabet"}
+            no_alpha = {k: v for k, v in self.constraints.items()
+                        if k != "alphabet"}
             return OrderedMultisetPartitionsIntoSets(fc["alphabet"], size, **no_alpha)
 
         # slice by 'size'
@@ -2028,7 +2029,12 @@ class OrderedMultisetPartitionsIntoSets_n(OrderedMultisetPartitionsIntoSets):
         TESTS::
 
             sage: C = OrderedMultisetPartitionsIntoSets(Integer(4))
-            sage: TestSuite(C).run()
+
+        We have to skip checking that elements are produced uniformly
+        at random by :meth:`random_element`, because this is not the
+        case.::
+
+            sage: TestSuite(C).run(skip="_test_random")
             sage: C2 = OrderedMultisetPartitionsIntoSets(int(4))
             sage: C is C2
             True
@@ -2202,18 +2208,24 @@ class OrderedMultisetPartitionsIntoSets_X(OrderedMultisetPartitionsIntoSets):
         TESTS::
 
             sage: C = OrderedMultisetPartitionsIntoSets([1,1,4])
-            sage: TestSuite(C).run()
+
+        We have to skip checking that elements are produced uniformly
+        at random by :meth:`random_element`, because this is not the
+        case.::
+
+            sage: TestSuite(C).run(skip="_test_random")
 
             sage: C2 = OrderedMultisetPartitionsIntoSets({1:2, 4:1})
             sage: C is C2
             True
+
         """
         self._X = X
         # sort the multiset
-        if all((k in ZZ and k > 0) for (k,v) in X):
-            self._Xtup = tuple([k for (k,v) in sorted(X) for _ in range(v)])
+        if all((k in ZZ and k > 0) for k, v in X):
+            self._Xtup = tuple([k for k, v in sorted(X) for _ in range(v)])
         else:
-            self._Xtup = tuple([k for (k,v) in sorted(X, key=str) for _ in range(v)])
+            self._Xtup = tuple([k for k, v in sorted(X, key=str) for _ in range(v)])
         OrderedMultisetPartitionsIntoSets.__init__(self, True)
 
     def _repr_(self):
@@ -2379,7 +2391,7 @@ class OrderedMultisetPartitionsIntoSets_X_constraints(OrderedMultisetPartitionsI
             sage: TestSuite(C).run()
         """
         self._X = X
-        self._Xtup = tuple(k for (k,v) in sorted(X) for _ in range(v))
+        self._Xtup = tuple(k for k, v in sorted(X) for _ in range(v))
         OrderedMultisetPartitionsIntoSets.__init__(self, True, weight=X, **constraints)
 
     def _repr_(self):
@@ -2415,7 +2427,12 @@ class OrderedMultisetPartitionsIntoSets_alph_d(OrderedMultisetPartitionsIntoSets
         TESTS::
 
             sage: C = OrderedMultisetPartitionsIntoSets(3, 2)
-            sage: TestSuite(C).run()
+
+        We have to skip checking that elements are produced uniformly
+        at random by :meth:`random_element`, because this is not the
+        case.::
+
+            sage: TestSuite(C).run(skip="_test_random")
 
             sage: C2 = OrderedMultisetPartitionsIntoSets([1,2,3], 2)
             sage: C is C2

sage/combinat/ncsf_qsym/generic_basis_code.py

@@ -12,7 +12,7 @@ AUTHORS:
 - Franco Saliola
 - Chris Berg
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2010 Jason Bandlow <jbandlow@gmail.com>,
 #                     2012 Franco Saliola <saliola@gmail.com>,
 #
@@ -25,8 +25,8 @@ AUTHORS:
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+#  ***************************************************************************
 
 from sage.misc.cachefunc import cached_method
 from sage.categories.realizations import Category_realization_of_parent
@@ -950,7 +950,7 @@ class BasesOfQSymOrNCSF(Category_realization_of_parent):
             EXAMPLES::
 
                 sage: S = NonCommutativeSymmetricFunctions(QQ).S()
-                sage: (x, y) = (S[2], S[3])
+                sage: x, y = S[2], S[3]
                 sage: x.degree()
                 2
                 sage: (x^3 + 4*y^2).degree()
@@ -961,7 +961,7 @@ class BasesOfQSymOrNCSF(Category_realization_of_parent):
             ::
 
                 sage: F = QuasiSymmetricFunctions(QQ).F()
-                sage: (x, y) = (F[2], F[3])
+                sage: x, y = F[2], F[3]
                 sage: x.degree()
                 2
                 sage: (x^3 + 4*y^2).degree()

sage/combinat/ncsf_qsym/ncsf.py

@@ -4,7 +4,7 @@
 Noncommutative symmetric functions
 """
 # ****************************************************************************
-#       Copyright (C) 2009 Nicolas M. Thiery <nthiery at users.sf.net>,
+#       Copyright (C) 2009 Nicolas M. Thiéry <nthiery at users.sf.net>,
 #                     2012 Franco Saliola <saliola@gmail.com>,
 #                     2012 Chris Berg <chrisjamesberg@gmail.com>
 #
@@ -17,7 +17,7 @@ Noncommutative symmetric functions
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
 # TODO: Make Coercion run faster between multiple bases
@@ -401,7 +401,7 @@ class NonCommutativeSymmetricFunctions(UniqueRepresentation, Parent):
         sage: TestSuite(complete).run()
     """
 
-    def __init__(self, R):
+    def __init__(self, R) -> None:
         r"""
         TESTS::
 
@@ -443,7 +443,7 @@ class NonCommutativeSymmetricFunctions(UniqueRepresentation, Parent):
         Phi.algebra_morphism(Phi._to_complete_on_generators,
                              codomain=complete).register_as_coercion()
 
-    def _repr_(self): # could be taken care of by the category
+    def _repr_(self) -> str:  # could be taken care of by the category
         r"""
         EXAMPLES::
 
@@ -470,7 +470,8 @@ class NonCommutativeSymmetricFunctions(UniqueRepresentation, Parent):
         """
         return self.complete()
 
-    _shorthands = tuple(['S', 'R', 'L', 'Phi', 'Psi', 'nM', 'I', 'dQS', 'dYQS', 'ZL', 'ZR'])
+    _shorthands = ('S', 'R', 'L', 'Phi', 'Psi', 'nM', 'I',
+                   'dQS', 'dYQS', 'ZL', 'ZR')
 
     def dual(self):
         r"""

sage/combinat/ncsf_qsym/qsym.py

@@ -92,15 +92,15 @@ from sage.combinat.partition import Partitions, _Partitions
 from sage.combinat.free_module import CombinatorialFreeModule
 from sage.combinat.sf.sf import SymmetricFunctions
 from sage.combinat.ncsf_qsym.generic_basis_code import BasesOfQSymOrNCSF
-from sage.combinat.ncsf_qsym.combinatorics import (number_of_fCT, number_of_SSRCT,
-                   compositions_order, coeff_pi, coeff_lp, coeff_sp, coeff_ell)
+from sage.combinat.ncsf_qsym.combinatorics import (
+    number_of_fCT, number_of_SSRCT,
+    compositions_order, coeff_pi, coeff_lp, coeff_sp, coeff_ell)
 from sage.combinat.ncsf_qsym.ncsf import NonCommutativeSymmetricFunctions
 from sage.combinat.words.word import Word
 from sage.combinat.tableau import StandardTableaux
 from sage.misc.bindable_class import BindableClass
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_import import lazy_import
-from sage.misc.superseded import deprecated_function_alias
 from sage.structure.parent import Parent
 from sage.structure.unique_representation import UniqueRepresentation
 
@@ -547,7 +547,7 @@ class QuasiSymmetricFunctions(UniqueRepresentation, Parent):
         True
     """
 
-    def __init__(self, R):
+    def __init__(self, R) -> None:
         """
         The Hopf algebra of quasi-symmetric functions.
         See ``QuasiSymmetricFunctions`` for full documentation.
@@ -610,7 +610,7 @@ class QuasiSymmetricFunctions(UniqueRepresentation, Parent):
                                              codomain=Fundamental, category=category)
         Sym_s_to_F.register_as_coercion()
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         EXAMPLES::
 
@@ -633,7 +633,7 @@ class QuasiSymmetricFunctions(UniqueRepresentation, Parent):
         """
         return self.Monomial()
 
-    _shorthands = tuple(['M', 'F', 'E', 'dI', 'QS', 'YQS', 'phi', 'psi'])
+    _shorthands = ('M', 'F', 'E', 'dI', 'QS', 'YQS', 'phi', 'psi')
 
     def dual(self):
         r"""
@@ -1156,8 +1156,6 @@ class QuasiSymmetricFunctions(UniqueRepresentation, Parent):
                 result_in_M_basis = M._from_dict(dct)
                 return parent(result_in_M_basis)
 
-            frobenius = deprecated_function_alias(36396, adams_operator)
-
             def star_involution(self):
                 r"""
                 Return the image of the quasisymmetric function ``self`` under
@@ -3538,26 +3536,20 @@ class QuasiSymmetricFunctions(UniqueRepresentation, Parent):
 
             # For every composition I of size n, expand self[I] in terms
             # of the monomial basis M.
-            i = 0
-            for I in compositions_n:
+            for i, I in enumerate(compositions_n):
                 # M_coeffs will be M(self[I])._monomial_coefficients
                 M_coeffs = {}
 
                 self_I_in_M_basis = M.prod([from_self_gen_function(self._indices(list(J)))
                                             for J in Word(I).lyndon_factorization()])
 
-                j = 0
-
-                for J in compositions_n:
+                for j, J in enumerate(compositions_n):
                     if J in self_I_in_M_basis._monomial_coefficients:
                         sp = self_I_in_M_basis._monomial_coefficients[J]
                         M_coeffs[J] = sp
-                        transition_matrix_n[i,j] = sp
-
-                    j += 1
+                        transition_matrix_n[i, j] = sp
 
                 from_self_cache[I] = M_coeffs
-                i += 1
 
             # Save the transition matrix
             inverse_transition_matrices[n] = transition_matrix_n

sage/combinat/ncsym/ncsym.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-combinat
 # sage.doctest: needs sage.combinat sage.modules
 """
-Symmetric functions in noncommuting variables
+Symmetric functions in non-commuting variables
 
 AUTHORS:
 
@@ -294,7 +294,7 @@ class SymmetricFunctionsNonCommutingVariables(UniqueRepresentation, Parent):
         -4*p[] + 2*p[1] + p[2, 2]
     """
 
-    def __init__(self, R):
+    def __init__(self, R) -> None:
         """
         Initialize ``self``.
 
@@ -310,7 +310,7 @@ class SymmetricFunctionsNonCommutingVariables(UniqueRepresentation, Parent):
         category = GradedHopfAlgebras(R).Cocommutative()
         Parent.__init__(self, category=category.WithRealizations())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         EXAMPLES::
 
@@ -332,7 +332,7 @@ class SymmetricFunctionsNonCommutingVariables(UniqueRepresentation, Parent):
         """
         return self.powersum()
 
-    _shorthands = tuple(['chi', 'cp', 'm', 'e', 'h', 'p', 'rho', 'x'])
+    _shorthands = ('chi', 'cp', 'm', 'e', 'h', 'p', 'rho', 'x')
 
     def dual(self):
         r"""
@@ -400,10 +400,8 @@ class SymmetricFunctionsNonCommutingVariables(UniqueRepresentation, Parent):
             def lt(s, t):
                 if s == t:
                     return False
-                for p in s:
-                    if len([z for z in t if z.intersection(p)]) != 1:
-                        return False
-                return True
+                return all(len([1 for z in t if z.intersection(p)]) == 1
+                           for p in s)
 
             p = self.realization_of().p()
             P = Poset((A.coarsenings(), lt))
@@ -1734,10 +1732,8 @@ class SymmetricFunctionsNonCommutingVariables(UniqueRepresentation, Parent):
             def lt(s, t):
                 if s == t:
                     return False
-                for p in s:
-                    if len([z for z in t if z.intersection(p)]) != 1:
-                        return False
-                return True
+                return all(len([1 for z in t if z.intersection(p)]) == 1
+                           for p in s)
 
             p = self.realization_of().p()
             P_refine = Poset((A.refinements(), lt))

sage/combinat/nu_dyck_word.py

@@ -1080,7 +1080,7 @@ class NuDyckWord(CombinatorialElement):
             return j
         return False
 
-    def mutate(self, i) -> None | NuDyckWord:
+    def mutate(self, i) -> NuDyckWord | None:
         r"""
         Return a new `\nu`-Dyck Word if possible.
 

sage/combinat/parallelogram_polyomino.py

@@ -1463,7 +1463,7 @@ class ParallelogramPolyomino(ClonableList,
             ....:         [1, 1, 0, 1, 1, 0, 0, 0, 1, 0]
             ....:     ]
             ....: )
-            sage: pp._to_binary_tree_Aval_Boussicault()
+            sage: pp._to_binary_tree_Aval_Boussicault()                                 # needs sage.graphs
             [[., [[., .], [[., [., .]], .]]], [[., .], .]]
 
             sage: pp = ParallelogramPolyomino([[0, 1], [1, 0]])
@@ -1522,7 +1522,7 @@ class ParallelogramPolyomino(ClonableList,
             ....:         [1, 1, 0, 1, 1, 0, 0, 0, 1, 0]
             ....:     ]
             ....: )
-            sage: pp.to_binary_tree()
+            sage: pp.to_binary_tree()                                                   # needs sage.graphs
             [[., [[., .], [[., [., .]], .]]], [[., .], .]]
 
             sage: pp = ParallelogramPolyomino([[0, 1], [1, 0]])
@@ -3149,9 +3149,7 @@ class ParallelogramPolyomino(ClonableList,
             return False
         if self[pos[0] - 1][pos[1]] == 0:
             return True
-        if self[pos[0]][pos[1] - 1] == 0:
-            return True
-        return False
+        return self[pos[0]][pos[1] - 1] == 0
 
     def box_is_root(self, box) -> bool:
         r"""

sage/combinat/parking_functions.py

@@ -64,7 +64,6 @@ AUTHORS:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 from __future__ import annotations
-from collections.abc import Iterator
 
 from sage.rings.integer import Integer
 from sage.rings.rational_field import QQ
@@ -81,6 +80,10 @@ from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
 from sage.categories.sets_with_grading import SetsWithGrading
 from sage.structure.parent import Parent
 from sage.structure.unique_representation import UniqueRepresentation
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
 
 
 def is_a(x, n=None) -> bool:
@@ -1002,7 +1005,7 @@ class ParkingFunction(ClonableArray, metaclass=InheritComparisonClasscallMetacla
 
             sage: # needs sage.modules
             sage: R = QQ['q','t'].fraction_field()
-            sage: (q,t) = R.gens()
+            sage: q, t = R.gens()
             sage: cqf = sum(t**PF.area() * PF.characteristic_quasisymmetric_function()
             ....:           for PF in ParkingFunctions(3)); cqf
             (q^3+q^2*t+q*t^2+t^3+q*t)*F[1, 1, 1] + (q^2+q*t+t^2+q+t)*F[1, 2]
@@ -1399,9 +1402,7 @@ class ParkingFunctions_all(ParkingFunctions):
             sage: x == y
             True
         """
-        if isinstance(S, ParkingFunctions_n):
-            return True
-        return False
+        return isinstance(S, ParkingFunctions_n)
 
 
 class ParkingFunctions_n(ParkingFunctions):

sage/combinat/partition_algebra.py

@@ -118,7 +118,7 @@ def SetPartitionsAk(k):
         sage: A3.random_element()  #random                                              # needs sage.symbolic
         {{1, 3, -3, -1}, {2, -2}}
 
-        sage: A3.cardinality()
+        sage: A3.cardinality()                                                          # needs sage.libs.flint
         203
 
         sage: A2p5 = SetPartitionsAk(2.5); A2p5
@@ -192,7 +192,7 @@ class SetPartitionsAkhalf_k(SetPartitions_set):
         s = self.k + 1
         return "Set partitions of {1, ..., %s, -1, ..., -%s} with %s and -%s in the same block" % (s, s, s, s)
 
-    def __contains__(self, x):
+    def __contains__(self, x) -> bool:
         """
         TESTS::
 
@@ -208,11 +208,8 @@ class SetPartitionsAkhalf_k(SetPartitions_set):
         if x not in SetPartitionsAk_k(self.k + 1):
             return False
 
-        for part in x:
-            if self.k + 1 in part and -self.k - 1 not in part:
-                return False
-
-        return True
+        return all(self.k + 1 not in part or -self.k - 1 in part
+                   for part in x)
 
     def __iter__(self):
         """
@@ -326,10 +323,7 @@ class SetPartitionsSk_k(SetPartitionsAk_k):
         if not SetPartitionsAk_k.__contains__(self, x):
             return False
 
-        if propagating_number(x) != self.k:
-            return False
-
-        return True
+        return propagating_number(x) == self.k
 
     def cardinality(self):
         """
@@ -385,9 +379,7 @@ class SetPartitionsSkhalf_k(SetPartitionsAkhalf_k):
         """
         if not SetPartitionsAkhalf_k.__contains__(self, x):
             return False
-        if propagating_number(x) != self.k + 1:
-            return False
-        return True
+        return propagating_number(x) == self.k + 1
 
     def _repr_(self):
         """
@@ -506,9 +498,7 @@ class SetPartitionsIk_k(SetPartitionsAk_k):
         """
         if not SetPartitionsAk_k.__contains__(self, x):
             return False
-        if propagating_number(x) >= self.k:
-            return False
-        return True
+        return propagating_number(x) < self.k
 
     def cardinality(self):
         """
@@ -559,9 +549,7 @@ class SetPartitionsIkhalf_k(SetPartitionsAkhalf_k):
         """
         if not SetPartitionsAkhalf_k.__contains__(self, x):
             return False
-        if propagating_number(x) >= self.k + 1:
-            return False
-        return True
+        return propagating_number(x) < self.k + 1
 
     def _repr_(self):
         """
@@ -616,6 +604,7 @@ def SetPartitionsBk(k):
         sage: B3 = SetPartitionsBk(3); B3
         Set partitions of {1, ..., 3, -1, ..., -3} with block size 2
 
+        sage: # needs sage.graphs
         sage: B3.first() #random
         {{2, -2}, {1, -3}, {3, -1}}
         sage: B3.last() #random
@@ -629,6 +618,7 @@ def SetPartitionsBk(k):
         sage: B2p5 = SetPartitionsBk(2.5); B2p5
         Set partitions of {1, ..., 3, -1, ..., -3} with 3 and -3 in the same block and with block size 2
 
+        sage: # needs sage.graphs
         sage: B2p5.first() #random
         {{2, -1}, {3, -3}, {1, -2}}
         sage: B2p5.last() #random
@@ -669,11 +659,7 @@ class SetPartitionsBk_k(SetPartitionsAk_k):
         if not SetPartitionsAk_k.__contains__(self, x):
             return False
 
-        for part in x:
-            if len(part) != 2:
-                return False
-
-        return True
+        return all(len(part) == 2 for part in x)
 
     def cardinality(self):
         r"""
@@ -703,14 +689,14 @@ class SetPartitionsBk_k(SetPartitionsAk_k):
         """
         TESTS::
 
-            sage: SetPartitionsBk(1).list()
+            sage: SetPartitionsBk(1).list()                                             # needs sage.graphs
             [{{-1, 1}}]
 
         ::
 
-            sage: SetPartitionsBk(2).list() #random
+            sage: SetPartitionsBk(2).list() #random                                     # needs sage.graphs
             [{{2, -1}, {1, -2}}, {{2, -2}, {1, -1}}, {{1, 2}, {-1, -2}}]
-            sage: SetPartitionsBk(3).list() #random
+            sage: SetPartitionsBk(3).list() #random                                     # needs sage.graphs
             [{{2, -2}, {1, -3}, {3, -1}},
              {{2, -1}, {1, -3}, {3, -2}},
              {{1, -3}, {2, 3}, {-1, -2}},
@@ -733,7 +719,7 @@ class SetPartitionsBk_k(SetPartitionsAk_k):
         ::
 
             sage: bks = [SetPartitionsBk(i) for i in range(1, 6)]
-            sage: all(bk.cardinality() == len(bk.list()) for bk in bks)
+            sage: all(bk.cardinality() == len(bk.list()) for bk in bks)                 # needs sage.graphs
             True
         """
         for sp in SetPartitions(self._set, [2] * (len(self._set) // 2)):
@@ -765,10 +751,7 @@ class SetPartitionsBkhalf_k(SetPartitionsAkhalf_k):
         """
         if not SetPartitionsAkhalf_k.__contains__(self, x):
             return False
-        for part in x:
-            if len(part) != 2:
-                return False
-        return True
+        return all(len(part) == 2 for part in x)
 
     def cardinality(self):
         """
@@ -880,10 +863,7 @@ class SetPartitionsPk_k(SetPartitionsAk_k):
         if not SetPartitionsAk_k.__contains__(self, x):
             return False
 
-        if not is_planar(x):
-            return False
-
-        return True
+        return is_planar(x)
 
     def cardinality(self):
         """
@@ -939,10 +919,7 @@ class SetPartitionsPkhalf_k(SetPartitionsAkhalf_k):
         """
         if not SetPartitionsAkhalf_k.__contains__(self, x):
             return False
-        if not is_planar(x):
-            return False
-
-        return True
+        return is_planar(x)
 
     def _repr_(self):
         """
@@ -1049,10 +1026,7 @@ class SetPartitionsTk_k(SetPartitionsBk_k):
         if not SetPartitionsBk_k.__contains__(self, x):
             return False
 
-        if not is_planar(x):
-            return False
-
-        return True
+        return is_planar(x)
 
     def cardinality(self):
         """
@@ -1102,10 +1076,7 @@ class SetPartitionsTkhalf_k(SetPartitionsBkhalf_k):
         """
         if not SetPartitionsBkhalf_k.__contains__(self, x):
             return False
-        if not is_planar(x):
-            return False
-
-        return True
+        return is_planar(x)
 
     def _repr_(self):
         """
@@ -1395,10 +1366,7 @@ class SetPartitionsPRk_k(SetPartitionsRk_k):
         if not SetPartitionsRk_k.__contains__(self, x):
             return False
 
-        if not is_planar(x):
-            return False
-
-        return True
+        return is_planar(x)
 
     def cardinality(self):
         """
@@ -1454,10 +1422,7 @@ class SetPartitionsPRkhalf_k(SetPartitionsRkhalf_k):
         if not SetPartitionsRkhalf_k.__contains__(self, x):
             return False
 
-        if not is_planar(x):
-            return False
-
-        return True
+        return is_planar(x)
 
     def _repr_(self):
         """

sage/combinat/partition_kleshchev.py

@@ -429,7 +429,7 @@ class KleshchevPartition(Partition):
         KP = mu.parent()
         return KP.element_class(KP, mu.add_cell(*mu.cogood_cells( r-c-self.parent()._multicharge[0]) ))
 
-    def is_regular(self):
+    def is_regular(self) -> bool:
         r"""
         Return ``True`` if ``self`` is a `e`-regular partition tuple.
 
@@ -455,7 +455,7 @@ class KleshchevPartition(Partition):
         KP = self.parent()
         return super().is_regular(KP._e, KP._multicharge)
 
-    def is_restricted(self):
+    def is_restricted(self) -> bool:
         r"""
         Return ``True`` if ``self`` is an `e`-restricted partition tuple.
 
@@ -812,7 +812,7 @@ class KleshchevPartitionTuple(PartitionTuple):
         KP = mu.parent()
         return KP.element_class(KP, mu.add_cell(*mu.cogood_cells( r-c-self.parent()._multicharge[k])))
 
-    def is_regular(self):
+    def is_regular(self) -> bool:
         r"""
         Return ``True`` if ``self`` is a `e`-regular partition tuple.
 
@@ -836,7 +836,7 @@ class KleshchevPartitionTuple(PartitionTuple):
         KP = self.parent()
         return _is_regular(self.to_list(), KP._multicharge, KP._convention)
 
-    def is_restricted(self):
+    def is_restricted(self) -> bool:
         r"""
         Return ``True`` if ``self`` is an `e`-restricted partition tuple.