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

sage/combinat/sf/powersum.py

@@ -3,7 +3,7 @@
 """
 Power sum symmetric functions
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>
 #                     2012 Mike Zabrocki <mike.zabrocki@gmail.com>
 #                     2012 Anne Schilling <anne at math.ucdavis.edu>
@@ -17,12 +17,11 @@ Power sum symmetric functions
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 from sage.arith.misc import divisors
 from sage.combinat.partition import Partition
 from sage.misc.misc_c import prod
-from sage.misc.superseded import deprecated_function_alias
 from sage.rings.infinity import infinity
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 
@@ -497,10 +496,6 @@ class SymmetricFunctionAlgebra_power(multiplicative.SymmetricFunctionAlgebra_mul
                    for lam, coeff in self.monomial_coefficients().items()}
             return self.parent()._from_dict(dct)
 
-        frobenius = deprecated_function_alias(36396, adams_operator)
-
-        adams_operation = deprecated_function_alias(36396, adams_operator)
-
         def verschiebung(self, n):
             r"""
             Return the image of the symmetric function ``self`` under the
@@ -798,6 +793,9 @@ class SymmetricFunctionAlgebra_power(multiplicative.SymmetricFunctionAlgebra_mul
                 sage: p.zero().principal_specialization(3)
                 0
             """
+            if n == 1:
+                return self.base_ring().sum(self.coefficients(sort=False))
+
             def get_variable(ring, name):
                 try:
                     ring(name)
@@ -927,12 +925,9 @@ class SymmetricFunctionAlgebra_power(multiplicative.SymmetricFunctionAlgebra_mul
                     t = get_variable(self.base_ring(), 't')
 
                 def f(partition):
-                    n = 0
-                    for part in partition:
-                        if part != 1:
-                            return 0
-                        n += 1
-                    return t**n
+                    if partition and partition[0] != 1:
+                        return 0
+                    return t**len(partition)
 
                 return self.parent()._apply_module_morphism(self, f, t.parent())
 

sage/combinat/sf/schur.py

@@ -693,6 +693,12 @@ class SymmetricFunctionAlgebra_schur(classical.SymmetricFunctionAlgebra_classica
                 sage: s.zero().principal_specialization(3)
                 0
             """
+            if n == 1:
+                R = self.base_ring()
+                mc = self.monomial_coefficients(copy=False).items()
+                return R.sum(c for partition, c in mc
+                             if len(partition) <= 1)
+
             def get_variable(ring, name):
                 try:
                     ring(name)

sage/combinat/sf/sf.py

@@ -3,7 +3,7 @@
 """
 Symmetric functions, with their multiple realizations
 """
-# ****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>
 #                     2009-2012 Jason Bandlow <jbandlow@gmail.com>
 #                     2012 Anne Schilling <anne at math.ucdavis.edu>
@@ -19,8 +19,8 @@ Symmetric functions, with their multiple realizations
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 from sage.categories.fields import Fields
 from sage.categories.graded_hopf_algebras import GradedHopfAlgebras
 from sage.categories.principal_ideal_domains import PrincipalIdealDomains
@@ -786,7 +786,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
 
         sage: # needs lrcalc_python
         sage: QQqt = QQ['q','t'].fraction_field()
-        sage: (q,t) = QQqt.gens()
+        sage: q, t = QQqt.gens()
         sage: st = SFA_st(SymmetricFunctions(QQqt),t)
         sage: st
         Symmetric Functions over Fraction Field of Multivariate Polynomial
@@ -895,7 +895,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
         """
         return self.schur()
 
-    def _repr_(self): # could be taken care of by the category
+    def _repr_(self):  # could be taken care of by the category
         r"""
         Representation of ``self``
 
@@ -917,7 +917,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
         """
         return schur.SymmetricFunctionAlgebra_schur(self)
     s = schur
-    Schur = schur # Currently needed by SymmetricFunctions.__init_extra__
+    Schur = schur  # Currently needed by SymmetricFunctions.__init_extra__
 
     def powersum(self):
         r"""
@@ -930,7 +930,8 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
         """
         return powersum.SymmetricFunctionAlgebra_power(self)
     p = powersum
-    power = powersum # Todo: get rid of this one when it won't be needed anymore
+    power = powersum
+    # Todo: get rid of the line above when it won't be needed anymore
 
     def complete(self):
         r"""
@@ -1262,7 +1263,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
             q^2*s[1, 1, 1, 1] + (q^2*t+q*t+q)*s[2, 1, 1] + (q^2*t^2+1)*s[2, 2] + (q*t^2+q*t+t)*s[3, 1] + t^2*s[4]
 
             sage: Sym = SymmetricFunctions(QQ['z','q'].fraction_field())
-            sage: (z,q) = Sym.base_ring().gens()
+            sage: z, q = Sym.base_ring().gens()
             sage: Hzq = Sym.macdonald(q=z,t=q).H()
             sage: H1z = Sym.macdonald(q=1,t=z).H()
             sage: s = Sym.schur()
@@ -1331,7 +1332,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
             sage: JQp = Sym.jack().Qp(); JQp
             Symmetric Functions over Fraction Field of Univariate Polynomial Ring in t over Rational Field in the Jack Qp basis
         """
-        return jack.Jack( self, t=t )
+        return jack.Jack(self, t=t)
 
     def abreu_nigro(self, q='q'):
         """
@@ -1355,7 +1356,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
             sage: SymmetricFunctions(QQ).zonal()
             Symmetric Functions over Rational Field in the zonal basis
         """
-        return jack.SymmetricFunctionAlgebra_zonal( self )
+        return jack.SymmetricFunctionAlgebra_zonal(self)
 
     def llt(self, k, t='t'):
         """
@@ -1379,7 +1380,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
             sage: llt3.hcospin()
             Symmetric Functions over Fraction Field of Univariate Polynomial Ring in t over Rational Field in the level 3 LLT cospin basis
         """
-        return llt.LLT_class( self, k, t=t )
+        return llt.LLT_class(self, k, t=t)
 
     def from_polynomial(self, f):
         """
@@ -1440,8 +1441,9 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
         else:
             morphism.codomain().register_coercion(morphism)
 
-    _shorthands = ['e', 'f', 'h', 'm', 'p', 's']
-    _shorthands_all = sorted(_shorthands + ['ht', 'o', 'sp', 'st', 'w'])
+    # keep them sorted in alphabetic order
+    _shorthands = ('e', 'f', 'h', 'm', 'p', 's')
+    _shorthands_all = ('e', 'f', 'h', 'ht', 'm', 'o', 'p', 's', 'sp', 'st', 'w')
 
     def __init_extra__(self):
         """
@@ -1462,11 +1464,11 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
             sage: f(p.an_element()) == p.an_element()
             True
         """
-        #powersum   = self.powersum  ()
-        #complete   = self.complete  ()
-        #elementary = self.elementary()
-        #schur      = self.schur     ()
-        #monomial   = self.monomial  ()
+        # powersum   = self.powersum  ()
+        # complete   = self.complete  ()
+        # elementary = self.elementary()
+        # schur      = self.schur     ()
+        # monomial   = self.monomial  ()
 
         iso = self.register_isomorphism
 
@@ -1475,7 +1477,7 @@ class SymmetricFunctions(UniqueRepresentation, Parent):
         for (basis1_name, basis2_name) in conversion_functions:
             basis1 = getattr(self, basis1_name)()
             basis2 = getattr(self, basis2_name)()
-            on_basis = SymmetricaConversionOnBasis(t=conversion_functions[basis1_name,basis2_name], domain=basis1, codomain=basis2)
+            on_basis = SymmetricaConversionOnBasis(t=conversion_functions[basis1_name, basis2_name], domain=basis1, codomain=basis2)
             from sage.rings.rational_field import RationalField
             if basis2_name != "powersum" or self._base.has_coerce_map_from(RationalField()):
                 iso(basis1._module_morphism(on_basis, codomain=basis2))

sage/combinat/sf/sfa.py

@@ -228,7 +228,6 @@ from sage.data_structures.blas_dict import convert_remove_zeroes, linear_combina
 from sage.matrix.constructor import matrix
 from sage.misc.cachefunc import cached_method
 from sage.misc.misc_c import prod
-from sage.misc.superseded import deprecated_function_alias
 from sage.rings.infinity import infinity
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
@@ -240,35 +239,6 @@ from sage.structure.element import coerce_binop
 from sage.structure.factorization import Factorization
 
 
-def is_SymmetricFunctionAlgebra(x):
-    """
-    Check whether ``x`` is a symmetric function algebra.
-
-    EXAMPLES::
-
-        sage: from sage.combinat.sf.sfa import is_SymmetricFunctionAlgebra
-        sage: is_SymmetricFunctionAlgebra(5)
-        doctest:warning...
-        DeprecationWarning: the function is_SymmetricFunctionAlgebra is deprecated;
-        use 'isinstance(..., SymmetricFunctionAlgebra_generic)' instead
-        See https://github.com/sagemath/sage/issues/37896 for details.
-        False
-        sage: is_SymmetricFunctionAlgebra(ZZ)
-        False
-        sage: is_SymmetricFunctionAlgebra(SymmetricFunctions(ZZ).schur())
-        True
-        sage: is_SymmetricFunctionAlgebra(SymmetricFunctions(QQ).e())
-        True
-        sage: is_SymmetricFunctionAlgebra(SymmetricFunctions(QQ).macdonald(q=1,t=1).P())
-        True
-        sage: is_SymmetricFunctionAlgebra(SymmetricFunctions(FractionField(QQ['q','t'])).macdonald().P())
-        True
-    """
-    from sage.misc.superseded import deprecation
-    deprecation(37896, "the function is_SymmetricFunctionAlgebra is deprecated; use 'isinstance(..., SymmetricFunctionAlgebra_generic)' instead")
-    return isinstance(x, SymmetricFunctionAlgebra_generic)
-
-
 def zee(part) -> Integer:
     r"""
     Return the size of the centralizer of any permutation of cycle type
@@ -298,32 +268,6 @@ def zee(part) -> Integer:
     return part.centralizer_size()
 
 
-def is_SymmetricFunction(x):
-    r"""
-    Check whether ``x`` is a symmetric function.
-
-    EXAMPLES::
-
-        sage: from sage.combinat.sf.sfa import is_SymmetricFunction
-        sage: s = SymmetricFunctions(QQ).s()
-        sage: is_SymmetricFunction(2)
-        doctest:warning...
-        DeprecationWarning: The function is_SymmetricFunction is deprecated;
-        use 'isinstance(..., SymmetricFunctionAlgebra_generic.Element)' instead.
-        See https://github.com/sagemath/sage/issues/38279 for details.
-        False
-        sage: is_SymmetricFunction(s(2))
-        True
-        sage: is_SymmetricFunction(s([2,1]))
-        True
-    """
-    from sage.misc.superseded import deprecation
-    deprecation(38279,
-                "The function is_SymmetricFunction is deprecated; "
-                "use 'isinstance(..., SymmetricFunctionAlgebra_generic.Element)' instead.")
-    return isinstance(x, SymmetricFunctionAlgebra_generic.Element)
-
-
 #####################################################################
 #  Bases categories
 
@@ -1479,9 +1423,7 @@ class SymmetricFunctionsBases(Category_realization_of_parent):
                 def check_word(w):
                     if sum(1 for i in range(n-1) if w[i] > w[i+1]) != d:
                         return False
-                    if sum(1 for i in range(n-1) if w[i] == w[i+1]) != s:
-                        return False
-                    return True
+                    return sum(1 for i in range(n - 1) if w[i] == w[i + 1]) == s
             elif comparison == -1:
                 def check_word(w):
                     if sum(1 for i in range(n-1) if w[i] > w[i+1]) != d:
@@ -1673,10 +1615,14 @@ class SymmetricFunctionsBases(Category_realization_of_parent):
 
                 sage: type(L)
                 <class 'sage.rings.lazy_series_ring.LazySymmetricFunctions_with_category'>
+                sage: s.completion() is s.formal_series_ring()
+                True
             """
             from sage.rings.lazy_series_ring import LazySymmetricFunctions
             return LazySymmetricFunctions(self)
 
+        completion = formal_series_ring
+
 
 class FilteredSymmetricFunctionsBases(Category_realization_of_parent):
     r"""
@@ -3568,6 +3514,11 @@ class SymmetricFunctionAlgebra_generic_Element(CombinatorialFreeModule.Element):
             sage: (1+p[2]).plethysm(p[2])
             p[] + p[4]
 
+        Fixed :issue:`41257`::
+
+            sage: s[[]](tensor([p[1], s[1]]))
+            p[] # s[]
+
         Check that degree one elements are treated in the correct way::
 
             sage: R.<a1,a2,a11,b1,b21,b111> = QQ[]
@@ -3645,11 +3596,11 @@ class SymmetricFunctionAlgebra_generic_Element(CombinatorialFreeModule.Element):
         if tensorflag:
             tparents = Px._sets
             lincomb = Px.linear_combination
-            elt = lincomb((prod(lincomb((tensor([p[r].plethysm(base(la))
+            elt = lincomb((prod((lincomb((tensor([p[r].plethysm(base(la))
                                                  for base, la in zip(tparents, trm)]),
                                          _raise_variables(c, r, degree_one))
                                         for trm, c in x)
-                                for r in mu),
+                                for r in mu), tensor([base.one() for base in tparents])),
                            d)
                           for mu, d in p(self))
             return Px(elt)
@@ -5157,7 +5108,7 @@ class SymmetricFunctionAlgebra_generic_Element(CombinatorialFreeModule.Element):
             -q^3 + 2*q^2 - 2*q + 1
             sage: a.scalar_qt(a,5,7) # q=5 and t=7
             490/1539
-            sage: (x,y) = var('x,y')                                                    # needs sage.symbolic
+            sage: x, y = var('x,y')                                                    # needs sage.symbolic
             sage: a.scalar_qt(a, q=x, t=y)                                              # needs sage.symbolic
             1/3*(x^3 - 1)/(y^3 - 1) + 2/3*(x - 1)^3/(y - 1)^3
             sage: Rn = QQ['q','t','y','z'].fraction_field()
@@ -5451,8 +5402,6 @@ class SymmetricFunctionAlgebra_generic_Element(CombinatorialFreeModule.Element):
         result_in_m_basis = m._from_dict(dct)
         return parent(result_in_m_basis)
 
-    frobenius = deprecated_function_alias(36396, adams_operator)
-
     def verschiebung(self, n):
         r"""
         Return the image of the symmetric function ``self`` under the

sage/combinat/shifted_primed_tableau.py

@@ -1090,7 +1090,7 @@ class CrystalElementShiftedPrimedTableau(ShiftedPrimedTableau):
         h, l = len(T), len(T[0])
 
         if (c+1 == l or T[r][c+1] is None or T[r][c+1] >= ind_plus_one):
-            (tp_r, tp_c) = (r, c)
+            tp_r, tp_c = (r, c)
             while True:
                 if tp_r+1 == h or T[tp_r+1][tp_c] is None or T[tp_r+1][tp_c] > ind_plus_one:
                     break
@@ -1264,7 +1264,7 @@ class CrystalElementShiftedPrimedTableau(ShiftedPrimedTableau):
             r, c = c, r
 
         if (c == 0 or T[r][c-1] is None or T[r][c-1] <= ind_e):
-            (tp_r, tp_c) = (r, c)
+            tp_r, tp_c = (r, c)
             while True:
                 if tp_r == 0 or T[tp_r-1][tp_c] is None or T[tp_r-1][tp_c] < ind_e:
                     break
@@ -1984,11 +1984,9 @@ class ShiftedPrimedTableaux(UniqueRepresentation, Parent):
                        for j in range(skew[i], len(row)-1)
                        if row[j].is_primed()):
                 return False
-        if not (self._primed_diagonal or all(row[0].is_unprimed()
-                   for i, row in enumerate(T)
-                   if skew[i] == 0)):
-            return False
-        return True
+        return self._primed_diagonal or all(row[0].is_unprimed()
+                                            for i, row in enumerate(T)
+                                            if skew[i] == 0)
 
 
 class ShiftedPrimedTableaux_all(ShiftedPrimedTableaux):

sage/combinat/shuffle.py

@@ -310,7 +310,7 @@ class SetShuffleProduct(ShuffleProduct_abstract):
             return (ll1 + ll2).binomial(ll2)
 
         return sum(comp_binom(el1, el2)
-                   for (el1, el2) in itertools.product(self._l1, self._l2))
+                   for el1, el2 in itertools.product(self._l1, self._l2))
 
 
 class ShuffleProduct(ShuffleProduct_abstract):

sage/combinat/sine_gordon.py

@@ -320,7 +320,7 @@ class SineGordonYsystem(SageObject):
         triangulation = []
         intervals = self.intervals()
         for a in range(self.F()):
-            for (first, last, typ) in intervals[a]:
+            for first, last, typ in intervals[a]:
                 if first - last in [vert(1), vert(-1)]:
                     continue
                 if typ == "L":
@@ -396,7 +396,7 @@ class SineGordonYsystem(SageObject):
         for a in range(self.F()):
             new_intervals = []
             if na[a] % 2 == 0:
-                for (first, last, typ) in intervals[a]:
+                for first, last, typ in intervals[a]:
                     if typ == "NR":
                         new_intervals.append((first, last, "R"))
                     elif typ == "NL":
@@ -417,7 +417,7 @@ class SineGordonYsystem(SageObject):
                             new_intervals.append((vert(x), vert(x + rk[a + 1]), "R"))
                             x = vert(x + rk[a + 1])
             else:
-                for (first, last, typ) in intervals[a]:
+                for first, last, typ in intervals[a]:
                     if typ == "NR":
                         new_intervals.append((first, last, "R"))
                     elif typ == "NL":
@@ -474,41 +474,21 @@ class SineGordonYsystem(SageObject):
         else:
             radius = ceil(self.r() / (2 * pi))
         points_opts = {}
-        if 'points_color' in kwds:
-            points_opts['color'] = kwds['points_color']
-        else:
-            points_opts['color'] = 'black'
-        if 'points_size' in kwds:
-            points_opts['size'] = kwds['points_size']
-        else:
-            points_opts['size'] = 7
+        points_opts['color'] = kwds.get('points_color', 'black')
+        points_opts['size'] = kwds.get('points_size', 7)
         triangulation_opts = {}
-        if 'triangulation_color' in kwds:
-            triangulation_opts['color'] = kwds['triangulation_color']
-        else:
-            triangulation_opts['color'] = 'black'
-        if 'triangulation_thickness' in kwds:
-            triangulation_opts['thickness'] = kwds['triangulation_thickness']
-        else:
-            triangulation_opts['thickness'] = 0.5
+        triangulation_opts['color'] = kwds.get('triangulation_color', 'black')
+        triangulation_opts['thickness'] = kwds.get('triangulation_thickness',
+                                                   0.5)
         shading_opts = {}
-        if 'shading_color' in kwds:
-            shading_opts['color'] = kwds['shading_color']
-        else:
-            shading_opts['color'] = 'lightgray'
+        shading_opts['color'] = kwds.get('shading_color', 'lightgray')
         reflections_opts = {}
-        if 'reflections_color' in kwds:
-            reflections_opts['color'] = kwds['reflections_color']
-        else:
-            reflections_opts['color'] = 'blue'
-        if 'reflections_thickness' in kwds:
-            reflections_opts['thickness'] = kwds['reflections_thickness']
-        else:
-            reflections_opts['thickness'] = 1
+        reflections_opts['color'] = kwds.get('reflections_color', 'blue')
+        reflections_opts['thickness'] = kwds.get('reflections_thickness', 1)
         # Helper functions
 
         def triangle(x):
-            (a, b) = sorted(x[:2])
+            a, b = sorted(x[:2])
             for p in self.vertices():
                 if (p, a) in self.triangulation() or (a, p) in self.triangulation():
                     if (p, b) in self.triangulation() or (b, p) in self.triangulation():
@@ -524,7 +504,7 @@ class SineGordonYsystem(SageObject):
             if p - q in [1, -1]:
                 def f(t):
                     return (radius * cos(t), radius * sin(t))
-                (p, q) = sorted([p, q])
+                p, q = sorted([p, q])
                 angle_p = vertex_to_angle(p)
                 angle_q = vertex_to_angle(q)
                 return parametric_plot(f(t), (t, angle_q, angle_p), **opts)
@@ -535,7 +515,7 @@ class SineGordonYsystem(SageObject):
                     angle_p += 2 * pi
                 internal_angle = angle_p - angle_q
                 if internal_angle > pi:
-                    (angle_p, angle_q) = (angle_q + 2 * pi, angle_p)
+                    angle_p, angle_q = (angle_q + 2 * pi, angle_p)
                     internal_angle = angle_p - angle_q
                 angle_center = (angle_p + angle_q) / 2
                 hypotenuse = radius / cos(internal_angle / 2)
@@ -575,7 +555,7 @@ class SineGordonYsystem(SageObject):
                                                max_level=1)
                             if x[2] in ["NR", "NL"]]
         shaded_triangles = map(triangle, neuter_intervals)
-        for (p, q, r) in shaded_triangles:
+        for p, q, r in shaded_triangles:
             points = list(plot_arc(radius, p, q)[0])
             points += list(plot_arc(radius, q, r)[0])
             points += list(reversed(plot_arc(radius, p, r)[0]))
@@ -583,7 +563,7 @@ class SineGordonYsystem(SageObject):
         # Disk boundary
         P += circle((0, 0), radius, **triangulation_opts)
         # Triangulation
-        for (p, q) in self.triangulation():
+        for p, q in self.triangulation():
             P += plot_arc(radius, p, q, **triangulation_opts)
         if self.type() == 'D':
             s = radius / 50.0
@@ -609,8 +589,8 @@ class SineGordonYsystem(SageObject):
         P += line([(0, 1.1 * radius), (0, -1.1 * radius)],
                   zorder=len(P), **reflections_opts)
         axis_angle = vertex_to_angle(-0.5 * (self.rk() + (1, 1))[1])
-        (a, b) = (1.1 * radius * cos(axis_angle),
-                  1.1 * radius * sin(axis_angle))
+        a, b = (1.1 * radius * cos(axis_angle),
+                1.1 * radius * sin(axis_angle))
         P += line([(a, b), (-a, -b)], zorder=len(P), **reflections_opts)
         # Wrap up
         P.set_aspect_ratio(1)

sage/combinat/skew_partition.py

@@ -128,7 +128,7 @@ AUTHORS:
 - Travis Scrimshaw (2013-02-11): Factored out ``CombinatorialClass``
 - Trevor K. Karn (2022-08-03): Add ``outside_corners``
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -140,8 +140,8 @@ AUTHORS:
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.structure.global_options import GlobalOptions
 from sage.structure.parent import Parent
@@ -590,7 +590,7 @@ class SkewPartition(CombinatorialElement):
         """
         return sum(self.row_lengths())
 
-    def is_connected(self):
+    def is_connected(self) -> bool:
         """
         Return ``True`` if ``self`` is a connected skew partition.
 
@@ -635,16 +635,16 @@ class SkewPartition(CombinatorialElement):
             sage: SkewPartition([[10,10],[1]]).overlap()
             9
         """
-        p,q = self
+        p, q = self
         if len(p) <= 1:
             from sage.rings.infinity import PlusInfinity
             return PlusInfinity()
         if len(q) == 0:
             return min(p)
         q = [q[0]] + list(q)
-        return min(row_lengths_aux([p,q]))
+        return min(row_lengths_aux([p, q]))
 
-    def is_overlap(self, n):
+    def is_overlap(self, n) -> bool:
         r"""
         Return ``True`` if the overlap of ``self`` is at most ``n``.
 
@@ -659,7 +659,7 @@ class SkewPartition(CombinatorialElement):
         """
         return n <= self.overlap()
 
-    def is_ribbon(self):
+    def is_ribbon(self) -> bool:
         r"""
         Return ``True`` if and only if ``self`` is a ribbon.
 
@@ -1552,10 +1552,7 @@ class SkewPartitions(UniqueRepresentation, Parent):
         if x[1] not in p:
             return False
 
-        if not p(x[0]).contains(p(x[1])):
-            return False
-
-        return True
+        return p(x[0]).contains(p(x[1]))
 
     def from_row_and_column_length(self, rowL, colL):
         """

sage/combinat/skew_tableau.py

@@ -176,8 +176,7 @@ class SkewTableau(ClonableList,
         """
         if isinstance(other, (Tableau, SkewTableau)):
             return list(self) == list(other)
-        else:
-            return list(self) == other or list(list(row) for row in self) == other
+        return list(self) == other or [list(row) for row in self] == other
 
     def __ne__(self, other):
         r"""
@@ -1812,11 +1811,7 @@ class SkewTableau(ClonableList,
                 v += 1
 
         # Check if lam[i]==mu[i] for all i >= v
-        for i in range(v, l_out):
-            if lam[i] != mu[i]:
-                return False
-
-        return True
+        return all(lam[i] == mu[i] for i in range(v, l_out))
 
     def to_ribbon(self, check_input=True):
         """

sage/combinat/sloane_functions.py

@@ -317,7 +317,7 @@ class SloaneSequence(SageObject):
             return self(n)
 
         LENGTH = 100000
-        (start, stop, step) = n.indices(2 * LENGTH)
+        start, stop, step = n.indices(2 * LENGTH)
         if abs(stop - start) > LENGTH:
             raise IndexError("slice (=%s) too long" % n)
         return [self(i) for i in range(start, stop, step) if i >= self.offset]