suggested details

Author: fchapoton

src/sage/combinat/composition_tableau.py

@@ -120,7 +120,7 @@ def __init__(self, parent, t):
 
         CombinatorialElement.__init__(self, parent, t)
 
-    def _repr_diagram(self):
+    def _repr_diagram(self) -> str:
         r"""
         Return a string representation of ``self`` as an array.
 
@@ -133,7 +133,7 @@ def _repr_diagram(self):
               4  4
         """
         return '\n'.join("".join("%3s" % str(x) for x in row)
-                          for row in self)
+                         for row in self)
 
     def __call__(self, *cell):
         r"""

src/sage/combinat/diagram_algebras.py

@@ -4558,59 +4558,59 @@ def is_planar(sp):
         sage: da.is_planar( da.to_set_partition([[1,-1],[2,-2]]))
         True
     """
-    #Singletons don't affect planarity
+    # Singletons don't affect planarity
     to_consider = [x for x in map(list, sp) if len(x) > 1]
     n = len(to_consider)
 
     for i in range(n):
-        #Get the positive and negative entries of this part
+        # Get the positive and negative entries of this part
         ap = [x for x in to_consider[i] if x > 0]
         an = [abs(x) for x in to_consider[i] if x < 0]
 
-        #Check if a includes numbers in both the top and bottom rows
+        # Check if a includes numbers in both the top and bottom rows
         if ap and an:
             for j in range(n):
                 if i == j:
                     continue
-                #Get the positive and negative entries of this part
+                # Get the positive and negative entries of this part
                 bp = [x for x in to_consider[j] if x > 0]
                 bn = [abs(x) for x in to_consider[j] if x < 0]
 
-                #Skip the ones that don't involve numbers in both
-                #the bottom and top rows
+                # Skip the ones that don't involve numbers in both
+                # the bottom and top rows
                 if not bn or not bp:
                     continue
 
-                #Make sure that if min(bp) > max(ap)
-                #then min(bn) >  max(an)
+                # Make sure that if min(bp) > max(ap)
+                # then min(bn) >  max(an)
                 if max(bp) > max(ap):
                     if min(bn) < min(an):
                         return False
 
-        #Go through the bottom and top rows
+        # Go through the bottom and top rows
         for row in [ap, an]:
             if len(row) > 1:
                 row.sort()
                 for s in range(len(row)-1):
                     if row[s] + 1 == row[s+1]:
-                        #No gap, continue on
+                        # No gap, continue on
                         continue
 
                     rng = list(range(row[s] + 1, row[s+1]))
 
-                    #Go through and make sure any parts that
-                    #contain numbers in this range are completely
-                    #contained in this range
+                    # Go through and make sure any parts that
+                    # contain numbers in this range are completely
+                    # contained in this range
                     for j in range(n):
                         if i == j:
                             continue
 
-                        #Make sure we make the numbers negative again
-                        #if we are in the bottom row
+                        # Make sure we make the numbers negative again
+                        # if we are in the bottom row
                         if row is ap:
                             sr = set(rng)
                         else:
-                            sr = set(-1*x for x in rng)
+                            sr = set(-x for x in rng)
 
                         sj = set(to_consider[j])
                         intersection = sr.intersection(sj)
@@ -4773,12 +4773,11 @@ def to_set_partition(l, k=None):
         [{-1, 1}, {-2, 3}, {2}, {-4, 4}, {-5, 5}, {-3}]
     """
     if k is None:
-        if l == []:
+        if not l:
             return []
-        else:
-            k = max( max( map(abs, x) ) for x in l )
+        k = max(max(map(abs, x)) for x in l)
 
-    to_be_added = set( list(range(1, ceil(k+1))) + [-1*x for x in range(1, ceil(k+1))] )
+    to_be_added = set(list(range(1, ceil(k+1))) + [-x for x in range(1, ceil(k+1))])
 
     sp = []
     for part in l:
@@ -4790,7 +4789,7 @@ def to_set_partition(l, k=None):
         i = to_be_added.pop()
         if -i in to_be_added:
             to_be_added.remove(-i)
-            sp.append(set([i,-i]))
+            sp.append(set([i, -i]))
         else:
             sp.append(set([i]))
 

src/sage/combinat/sf/sfa.py

@@ -196,7 +196,7 @@
 - Darij Grinberg (2013) Sym over rings that are not characteristic 0
 
 """
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2007 Mike Hansen <[email protected]>
 #                     2012 Anne Schilling <anne at math.ucdavis.edu>
 #                     2012 Mike Zabrocki <[email protected]>
@@ -210,8 +210,8 @@
 #
 #  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.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
@@ -306,7 +306,7 @@ def is_SymmetricFunction(x):
     return isinstance(x, SymmetricFunctionAlgebra_generic.Element)
 
 #####################################################################
-## Bases categories
+#  Bases categories
 
 
 from sage.categories.realizations import Category_realization_of_parent
@@ -4620,7 +4620,7 @@ def internal_coproduct(self):
         @cached_function
         def hnimage(n):
             return result_parent.sum(tensor([parent(s(lam)), parent(s(lam))])
-                                      for lam in Partitions(n))
+                                     for lam in Partitions(n))
         for lam, a in h(self):
             result += a * prod(hnimage(i) for i in lam)
         return result
@@ -5588,7 +5588,7 @@ def _is_positive(self, s):
             True
         """
         s_self = s(self)
-        return all( _nonnegative_coefficients(c) for c in s_self.coefficients() )
+        return all(_nonnegative_coefficients(c) for c in s_self.coefficients())
 
     def degree(self):
         r"""