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

sage/combinat/diagram_algebras.py

@@ -358,7 +358,7 @@ class AbstractPartitionDiagram(AbstractSetPartition):
             sage: pd2 = da.AbstractPartitionDiagram(pd, [[[1,2],[-1,-2]]]) # indirect doctest
             Traceback (most recent call last):
             ...
-            TypeError: unhashable type: 'list'
+            TypeError: ...unhashable type: 'list'...
         """
         if self._base_diagram:
             tst = frozenset(e for B in self._base_diagram for e in B)
@@ -502,7 +502,7 @@ class AbstractPartitionDiagram(AbstractSetPartition):
             sage: pd([[1,2],[-1,-2]]).compose(pd([[1,2],[-1,-2]]))
             ({{-2, -1}, {1, 2}}, 1)
         """
-        (composite_diagram, loops_removed) = set_partition_composition(self._base_diagram, other._base_diagram)
+        composite_diagram, loops_removed = set_partition_composition(self._base_diagram, other._base_diagram)
         return (self.__class__(self.parent(), composite_diagram, check=check), loops_removed)
 
     def propagating_number(self):
@@ -566,7 +566,7 @@ class AbstractPartitionDiagram(AbstractSetPartition):
         """
         return self.parent().order
 
-    def is_planar(self):
+    def is_planar(self) -> bool:
         r"""
         Test if the diagram ``self`` is planar.
 
@@ -999,7 +999,7 @@ class BrauerDiagram(AbstractPartitionDiagram):
             sage: bd([[1,4],[6,7], [-2,-6],[-5,-7], [2,-4],[3,-1],[5,-3]])._repr_compact()
             '[14.67/26.57;312]'
         """
-        (top, bot, thru) = self.involution_permutation_triple()
+        top, bot, thru = self.involution_permutation_triple()
         bot.reverse()
         s1 = ".".join("".join(str(b) for b in block) for block in top)
         s2 = ".".join("".join(str(abs(k)) for k in sorted(block, reverse=True))
@@ -1109,7 +1109,7 @@ class BrauerDiagram(AbstractPartitionDiagram):
                 std[short_form.index(i)] = j
         return std
 
-    def is_elementary_symmetric(self):
+    def is_elementary_symmetric(self) -> bool:
         r"""
         Check if is elementary symmetric.
 
@@ -1128,10 +1128,10 @@ class BrauerDiagram(AbstractPartitionDiagram):
             sage: elm2.is_elementary_symmetric()
             False
         """
-        (D1,D2,pi) = self.involution_permutation_triple()
+        D1, D2, pi = self.involution_permutation_triple()
         D1 = sorted(sorted(abs(y) for y in x) for x in D1)
         D2 = sorted(sorted(abs(y) for y in x) for x in D2)
-        return D1 == D2 and pi == list(range(1,len(pi)+1))
+        return D1 == D2 and pi == list(range(1, len(pi) + 1))
 
 
 class AbstractPartitionDiagrams(Parent, UniqueRepresentation):
@@ -1329,9 +1329,8 @@ class AbstractPartitionDiagrams(Parent, UniqueRepresentation):
                 return False
         if obj.base_diagram():
             tst = sorted(flatten(obj.base_diagram()))
-            if len(tst) % 2 or tst != list(range(-len(tst)//2,0)) + list(range(1,len(tst)//2+1)):
-                return False
-            return True
+            ell = len(tst)
+            return not ell % 2 and tst == list(range(-ell // 2, 0)) + list(range(1, ell // 2 + 1))
         return self.order == 0
 
     def _element_constructor_(self, d):
@@ -1617,7 +1616,7 @@ class BrauerDiagrams(AbstractPartitionDiagrams):
             raise NotImplementedError("only implemented for integer order,"
                                       " not for order %s" % (self.order))
         try:
-            (D1,D2,pi) = tuple(D1_D2_pi)
+            D1, D2, pi = tuple(D1_D2_pi)
         except ValueError:
             raise ValueError("argument %s not in correct form; must be a tuple (D1, D2, pi)" % D1_D2_pi)
         D1 = [[abs(x) for x in b] for b in D1 if len(b) == 2] # not needed if argument correctly passed at outset.
@@ -2205,7 +2204,7 @@ class DiagramBasis(DiagramAlgebra):
             d1 = self._indices(d1)
         if not self._indices.is_parent_of(d2):
             d2 = self._indices(d2)
-        (composite_diagram, loops_removed) = d1.compose(d2, check=False)
+        composite_diagram, loops_removed = d1.compose(d2, check=False)
         return self.term(composite_diagram, self._q**loops_removed)
 
 
@@ -4493,7 +4492,6 @@ class TemperleyLiebAlgebra(SubPartitionAlgebra, UnitDiagramMixin):
                o o o o      o o o o       o o o o
         """
         M = x.monomial_coefficients(copy=False)
-        I = self._indices
         return self._from_dict({d.dual(): c for d, c in M.items()},
                                remove_zeros=False)
 
@@ -5578,7 +5576,7 @@ class PottsRepresentation(CombinatorialFreeModule):
 #########################################################################
 
 
-def is_planar(sp):
+def is_planar(sp) -> bool:
     r"""
     Return ``True`` if the diagram corresponding to the set partition ``sp``
     is planar; otherwise, return ``False``.

sage/combinat/dyck_word.py

@@ -78,7 +78,6 @@ REFERENCES:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 from __future__ import annotations
-from collections.abc import Iterator
 
 from .combinat import CombinatorialElement, catalan_number
 from sage.combinat.combinatorial_map import combinatorial_map
@@ -98,6 +97,10 @@ from sage.combinat.words.word import Word
 from sage.combinat.set_partition import SetPartitions
 from sage.misc.latex import latex
 from sage.misc.lazy_import import lazy_import
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
 
 lazy_import('sage.combinat.alternating_sign_matrix', 'AlternatingSignMatrices')
 
@@ -927,11 +930,10 @@ class DyckWord(CombinatorialElement):
         horizontal = "<line x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\"/>"
         hori_lines = []
         path = ['<polyline points=\"0,0']
-        x, y = 0, 0
+        y = 0
         max_y = 0
         last_seen_level = [0]
-        for e in self:
-            x += 1
+        for x, e in enumerate(self, start=1):
             if e == open_symbol:
                 y += 1
                 last_seen_level.append(x - 1)
@@ -2060,7 +2062,7 @@ class DyckWord_complete(DyckWord):
         EXAMPLES::
 
             sage: R = QQ['q','t'].fraction_field()
-            sage: (q,t) = R.gens()
+            sage: q, t = R.gens()
             sage: f = sum(t**D.area() * D.characteristic_symmetric_function()           # needs sage.modules
             ....:         for D in DyckWords(3)); f
             (q^3+q^2*t+q*t^2+t^3+q*t)*s[1, 1, 1] + (q^2+q*t+t^2+q+t)*s[2, 1] + s[3]
@@ -2697,7 +2699,7 @@ class DyckWord_complete(DyckWord):
                        bseq[bpeak[-i - 1]] - bseq[bpeak[-i - 1] + 1] + 1)
         return out
 
-    def tunnels(self):
+    def tunnels(self) -> Iterator[tuple[int, int]]:
         r"""
         Return an iterator of ranges of the matching parentheses in the Dyck
         word ``self``.
@@ -2747,15 +2749,14 @@ class DyckWord_complete(DyckWord):
         n = len(self)
         tunnels = self.tunnels()
         if tunnel_type == 'left':
-            return len([1 for (i, j) in tunnels if i + j < n])
-        elif tunnel_type == 'centered':
-            return len([1 for (i, j) in tunnels if i + j == n])
-        elif tunnel_type == 'right':
-            return len([1 for (i, j) in tunnels if i + j > n])
-        elif tunnel_type == 'all':
+            return len([1 for i, j in tunnels if i + j < n])
+        if tunnel_type == 'centered':
+            return len([1 for i, j in tunnels if i + j == n])
+        if tunnel_type == 'right':
+            return len([1 for i, j in tunnels if i + j > n])
+        if tunnel_type == 'all':
             return len(list(tunnels))
-        else:
-            raise ValueError("the given tunnel_type is not valid")
+        raise ValueError("the given tunnel_type is not valid")
 
     @combinatorial_map(order=2, name="Reverse path")
     def reverse(self) -> DyckWord:

sage/combinat/e_one_star.py

@@ -849,7 +849,7 @@ class Patch(SageObject):
         else:
             return Patch(self._faces.difference(other))
 
-    def dimension(self) -> None | int:
+    def dimension(self) -> int | None:
         r"""
         Return the dimension of the vectors of the faces of ``self``.
 

sage/combinat/fqsym.py

@@ -364,8 +364,14 @@ class FreeQuasisymmetricFunctions(UniqueRepresentation, Parent):
 
             sage: F = algebras.FQSym(QQ)
             sage: TestSuite(F).run() # long time (3s)
+
+            sage: F = algebras.FQSym(ZZ).F()
+            sage: F.is_commutative()
+            False
         """
         category = HopfAlgebras(R).Graded().Connected()
+        if R.is_zero():
+            category = category.Commutative()
         Parent.__init__(self, base=R, category=category.WithRealizations())
 
         # Bases
@@ -401,7 +407,7 @@ class FreeQuasisymmetricFunctions(UniqueRepresentation, Parent):
         """
         return self.F()
 
-    _shorthands = tuple(['F', 'G', 'M'])
+    _shorthands = ('F', 'G', 'M')
 
     class F(FQSymBasis_abstract):
         r"""
@@ -689,7 +695,7 @@ class FreeQuasisymmetricFunctions(UniqueRepresentation, Parent):
                     raise ValueError("n must be at least the maximal degree")
 
                 SGA = SymmetricGroupAlgebra(self.base_ring(), n)
-                return SGA._from_dict({Permutations(n)(key): c for (key, c) in self})
+                return SGA._from_dict({Permutations(n)(key): c for key, c in self})
 
     class G(FQSymBasis_abstract):
         r"""
@@ -1219,7 +1225,7 @@ class FreeQuasisymmetricFunctions(UniqueRepresentation, Parent):
                 # See the FQSymBases.ElementMethods.star_involution doc
                 # for the formula we're using here.
                 M = self.parent()
-                return M._from_dict({w.complement().reverse(): c for (w, c) in self},
+                return M._from_dict({w.complement().reverse(): c for w, c in self},
                                     remove_zeros=False)
 
 
@@ -1351,18 +1357,6 @@ class FQSymBases(Category_realization_of_parent):
             """
             return False
 
-        def is_commutative(self):
-            """
-            Return whether this `FQSym` is commutative.
-
-            EXAMPLES::
-
-                sage: F = algebras.FQSym(ZZ).F()
-                sage: F.is_commutative()
-                False
-            """
-            return self.base_ring().is_zero()
-
         def some_elements(self):
             """
             Return some elements of the free quasi-symmetric functions.
@@ -1523,7 +1517,7 @@ class FQSymBases(Category_realization_of_parent):
                 sage: A.from_symmetric_group_algebra(SGA4.zero())
                 0
             """
-            return self._from_dict({Permutation(key): c for (key, c) in x})
+            return self._from_dict({Permutation(key): c for key, c in x})
 
     class ElementMethods:
         def omega_involution(self):
@@ -1634,7 +1628,7 @@ class FQSymBases(Category_realization_of_parent):
             # componentwise, then convert back.
             parent = self.parent()
             F = parent.realization_of().F()
-            dct = {I.reverse(): coeff for (I, coeff) in F(self)}
+            dct = {I.reverse(): coeff for I, coeff in F(self)}
             return parent(F._from_dict(dct, remove_zeros=False))
 
         def psi_involution(self):
@@ -1736,7 +1730,7 @@ class FQSymBases(Category_realization_of_parent):
             # componentwise, then convert back.
             parent = self.parent()
             F = parent.realization_of().F()
-            dct = {I.complement(): coeff for (I, coeff) in F(self)}
+            dct = {I.complement(): coeff for I, coeff in F(self)}
             return parent(F._from_dict(dct, remove_zeros=False))
 
         def star_involution(self):
@@ -1856,7 +1850,7 @@ class FQSymBases(Category_realization_of_parent):
             # complement componentwise, then convert back.
             parent = self.parent()
             F = parent.realization_of().F()
-            dct = {I.complement().reverse(): coeff for (I, coeff) in F(self)}
+            dct = {I.complement().reverse(): coeff for I, coeff in F(self)}
             return parent(F._from_dict(dct, remove_zeros=False))
 
         def to_symmetric_group_algebra(self, n=None):

sage/combinat/free_dendriform_algebra.py

@@ -314,7 +314,7 @@ class FreeDendriformAlgebra(CombinatorialFreeModule):
             sage: A.degree_on_basis(u.over(u))
             2
         """
-        return t.node_number()
+        return t.number_of_nodes()
 
     def _an_element_(self):
         """
@@ -628,7 +628,7 @@ class FreeDendriformAlgebra(CombinatorialFreeModule):
         """
         B = self.basis()
         Trees = B.keys()
-        if not x.node_number():
+        if not x.number_of_nodes():
             return self.one().tensor(self.one())
         L, R = list(x)
         try:

sage/combinat/free_prelie_algebra.py

@@ -374,7 +374,7 @@ class FreePreLieAlgebra(CombinatorialFreeModule):
             sage: A.degree_on_basis(RT([RT([])]))
             2
         """
-        return t.node_number()
+        return t.number_of_nodes()
 
     def _an_element_(self):
         """
@@ -610,7 +610,7 @@ class FreePreLieAlgebra(CombinatorialFreeModule):
         resu = self.zero()
         for k in range(min_deg, N + 1):   # total degree of (x ; y, y, y, y)
             for mx, coef_x in xx:
-                dx = mx.node_number()
+                dx = mx.number_of_nodes()
                 step = self.zero()
                 for pi in IntegerVectors(k - dx, n, min_part=vy, max_part=max_y):
                     for ly in product(*[y_homog[part] for part in pi]):

sage/combinat/fully_commutative_elements.py

@@ -29,8 +29,6 @@ Natalie Schoenhals for their contribution to the project and the code.
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
-from collections import deque
-
 from sage.categories.coxeter_groups import CoxeterGroups
 from sage.categories.enumerated_sets import EnumeratedSets
 from sage.misc.lazy_import import lazy_import
@@ -159,7 +157,9 @@ class FullyCommutativeElement(NormalizedClonableList):
             False
         """
         word = list(self)
-        from sage.combinat.root_system.braid_orbit import is_fully_commutative as is_fully_comm
+        from sage.combinat.root_system.braid_orbit import (
+            is_fully_commutative as is_fully_comm,
+        )
 
         group = self.parent().coxeter_group()
         braid_rels = group.braid_relations()
@@ -272,7 +272,7 @@ class FullyCommutativeElement(NormalizedClonableList):
         levels = h.level_sets()
         letters_at_level = [set(self[i] for i in level) for level in levels]
 
-        for (level_zero_index, members) in enumerate(levels):
+        for level_zero_index, members in enumerate(levels):
             level = level_zero_index + 1
             for i in members:
                 x = self[i]
@@ -440,7 +440,7 @@ class FullyCommutativeElement(NormalizedClonableList):
         view = list(self) if side == 'left' else self[::-1]
         m = self.parent().coxeter_group().coxeter_matrix()
         out = set()
-        for (i, t) in enumerate(view):
+        for i, t in enumerate(view):
             if not any(m[x, t] > 2 for x in view[:i]):
                 out.add(t)
         return out
@@ -713,9 +713,9 @@ class FullyCommutativeElement(NormalizedClonableList):
 
         # Perform the coset decomposition on the specified side:
         if side == 'left':
-            (string, remaining) = self.coset_decomposition(J, side=side)
+            string, remaining = self.coset_decomposition(J, side=side)
         elif side == 'right':
-            (remaining, string) = self.coset_decomposition(J, side=side)
+            remaining, string = self.coset_decomposition(J, side=side)
 
         cur_string = list(string)
 
@@ -1012,7 +1012,7 @@ class FullyCommutativeElements(UniqueRepresentation, Parent):
         letters = self.coxeter_group().index_set()
 
         # To make the iterator deterministic, use a dictionary rather than a
-        # set, for the keys are then ordered by default by Python 3.7+:
+        # set, for the keys are then ordered by default:
         recent_words = {empty_word: True}
         yield empty_word
         while recent_words:

sage/combinat/fully_packed_loop.py

@@ -307,7 +307,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
         sage: ASMs = AlternatingSignMatrices(3).list()
         sage: ncp = FullyPackedLoop(ASMs[1]).link_pattern() # fpl's gyration orbit size is 2
         sage: rotated_ncp=[]
-        sage: for (a,b) in ncp:
+        sage: for a, b in ncp:
         ....:     for i in range(5):
         ....:         a,b=a%6+1,b%6+1;
         ....:     rotated_ncp.append((a,b))
@@ -318,7 +318,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
         sage: fpl = FullyPackedLoop(ASMs[0])
         sage: ncp = fpl.link_pattern() # fpl's gyration size is 3
         sage: rotated_ncp=[]
-        sage: for (a,b) in ncp:
+        sage: for a, b in ncp:
         ....:     for i in range(5):
         ....:         a,b=a%6+1,b%6+1;
         ....:     rotated_ncp.append((a,b))
@@ -331,7 +331,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
         sage: fpl = FullyPackedLoop(mat) # n=7
         sage: ncp = fpl.link_pattern()
         sage: rotated_ncp=[]
-        sage: for (a,b) in ncp:
+        sage: for a, b in ncp:
         ....:     for i in range(13):
         ....:         a,b=a%14+1,b%14+1;
         ....:     rotated_ncp.append((a,b))
@@ -344,7 +344,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
         sage: fpl = FullyPackedLoop(mat) # n =6
         sage: ncp = fpl.link_pattern()
         sage: rotated_ncp=[]
-        sage: for (a,b) in ncp:
+        sage: for a, b in ncp:
         ....:     for i in range(11):
         ....:         a,b=a%12+1,b%12+1;
         ....:     rotated_ncp.append((a,b))
@@ -762,7 +762,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
           its order. Setting this option to ``True`` makes it unlikely to
           have two neighboring links with the same color.
 
-        - ``loop_fill`` -- (boolean, optional) whether to fill the interior of the loops
+        - ``loop_fill`` -- boolean (default: ``False``); whether to fill the interior of the loops
 
         EXAMPLES:
 
@@ -1082,7 +1082,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
             sage: ASMs = AlternatingSignMatrices(3).list()
             sage: ncp = FullyPackedLoop(ASMs[1]).link_pattern()
             sage: rotated_ncp=[]
-            sage: for (a,b) in ncp:
+            sage: for a, b in ncp:
             ....:     for i in range(5):
             ....:         a,b=a%6+1,b%6+1;
             ....:     rotated_ncp.append((a,b))
@@ -1093,7 +1093,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
             sage: fpl = FullyPackedLoop(ASMs[0])
             sage: ncp = fpl.link_pattern()
             sage: rotated_ncp=[]
-            sage: for (a,b) in ncp:
+            sage: for a, b in ncp:
             ....:     for i in range(5):
             ....:         a,b=a%6+1,b%6+1;
             ....:     rotated_ncp.append((a,b))
@@ -1106,7 +1106,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
             sage: fpl = FullyPackedLoop(mat) # n=7
             sage: ncp = fpl.link_pattern()
             sage: rotated_ncp=[]
-            sage: for (a,b) in ncp:
+            sage: for a, b in ncp:
             ....:     for i in range(13):
             ....:         a,b=a%14+1,b%14+1;
             ....:     rotated_ncp.append((a,b))
@@ -1119,7 +1119,7 @@ class FullyPackedLoop(Element, metaclass=InheritComparisonClasscallMetaclass):
             sage: fpl = FullyPackedLoop(mat)
             sage: ncp = fpl.link_pattern()
             sage: rotated_ncp=[]
-            sage: for (a,b) in ncp:
+            sage: for a, b in ncp:
             ....:     for i in range(11):
             ....:         a,b=a%12+1,b%12+1;
             ....:     rotated_ncp.append((a,b))

sage/combinat/gelfand_tsetlin_patterns.py

@@ -705,10 +705,9 @@ class GelfandTsetlinPatterns(UniqueRepresentation, Parent):
                    for i in range(1, len(gt)) for j in range(len(gt[i]))):
             return False
         # Check if it is strict if applicable
-        if self._strict and any(gt[i][j] == gt[i][j-1] for i in range(len(gt))
-                                for j in range(1, len(gt[i]))):
-            return False
-        return True
+        return not (self._strict and any(gt[i][j] == gt[i][j - 1]
+                                         for i in range(len(gt))
+                                         for j in range(1, len(gt[i]))))
 
     def _repr_(self):
         """
@@ -1182,7 +1181,7 @@ class GelfandTsetlinPatterns(UniqueRepresentation, Parent):
             elif self._k < 0:
                 raise ValueError('cannot sample from empty set')
             else:
-                return self._cftp(0)
+                return self.element_class(self, self._cftp(0))
         else:
             raise ValueError('cannot sample from infinite set')
 

sage/combinat/gray_codes.py

@@ -70,19 +70,18 @@ def product(m):
         ....:     assert sum(1 for _ in product(t)) == prod(t)-1
     """
     # n is the length of the element (we ignore sets of size 1)
-    n = k = 0
+    n = 0
 
     new_m = []   # will be the set of upper bounds m_i different from 1
     mm = []      # index of each set (we skip sets of cardinality 1)
-    for i in m:
+    for k, i in enumerate(m):
         i = int(i)
         if i <= 0:
             raise ValueError("accept only positive integers")
         if i > 1:
-            new_m.append(i-1)
+            new_m.append(i - 1)
             mm.append(k)
             n += 1
-        k += 1
 
     m = new_m
     f = list(range(n + 1))  # focus pointer

sage/combinat/grossman_larson_algebras.py

@@ -360,7 +360,7 @@ class GrossmanLarsonAlgebra(CombinatorialFreeModule):
             sage: A.degree_on_basis(RT([RT([])]))
             1
         """
-        return t.node_number() - 1
+        return t.number_of_nodes() - 1
 
     def _an_element_(self):
         """
@@ -509,7 +509,7 @@ class GrossmanLarsonAlgebra(CombinatorialFreeModule):
             sage: A.counit_on_basis(RT([],'#'))
             1
         """
-        if x.node_number() == 1:
+        if x.number_of_nodes() == 1:
             return self.base_ring().one()
         return self.base_ring().zero()
 

sage/combinat/growth.py

@@ -748,7 +748,7 @@ class GrowthDiagram(SageObject):
             sage: G.out_labels() == G.conjugate().out_labels()[::-1]
             True
         """
-        F = {(j,i): v for (i,j),v in self._filling.items()}
+        F = {(j, i): v for (i, j), v in self._filling.items()}
         return GrowthDiagram(self.rule,
                              filling=F,
                              shape=self.shape().conjugate(),
@@ -803,7 +803,7 @@ class GrowthDiagram(SageObject):
         shape_lambda = [l - p for p in self._mu] + [l] * (h - len(self._mu))
         shape_mu = [l - p for p in self._lambda]
         shape = SkewPartition([shape_lambda[::-1], shape_mu[::-1]])
-        F = {(l-i-1, h-j-1): v for (i,j),v in self._filling.items()}
+        F = {(l-i-1, h-j-1): v for (i, j), v in self._filling.items()}
         return GrowthDiagram(self.rule,
                              filling=F,
                              shape=shape)
@@ -996,7 +996,7 @@ class GrowthDiagram(SageObject):
         if not self.is_rectangular():
             raise ValueError("can only convert fillings of rectangular shapes to words")
         w = [0] * self._lambda[0]
-        for ((i,j), v) in self._filling.items():
+        for (i, j), v in self._filling.items():
             if v != 0:
                 if v == 1:
                     if w[i] == 0:
@@ -1044,7 +1044,7 @@ class GrowthDiagram(SageObject):
             raise ValueError("can only convert fillings of rectangular shapes to words")
         w1 = []
         w2 = []
-        for ((i,j), v) in sorted(self._filling.items()):
+        for (i, j), v in sorted(self._filling.items()):
             if v >= 0:
                 w1.extend([i+1]*v)
                 w2.extend([j+1]*v)
@@ -1410,13 +1410,13 @@ class GrowthDiagram(SageObject):
                 if isinstance(v, dict):
                     # it is a dict of dicts
                     F = dict()
-                    for (i, row) in filling.items():
-                        for (j, v) in row.items():
+                    for i, row in filling.items():
+                        for j, v in row.items():
                             if v != 0:
-                                F[(i,j)] = int(v)
+                                F[(i, j)] = int(v)
                 else:
                     # it is dict of coordinates
-                    F = {(i,j): v for ((i,j), v) in filling.items()
+                    F = {(i, j): v for (i, j), v in filling.items()
                          if v != 0}
             except StopIteration:
                 # it is an empty dict of coordinates
@@ -3005,7 +3005,7 @@ class RuleSylvester(Rule):
             sage: Sylvester.rank(Sylvester.vertices(3)[0])
             3
         """
-        return v.node_number()
+        return v.number_of_nodes()
 
     def is_Q_edge(self, v, w):
         r"""
@@ -3149,7 +3149,7 @@ class RuleSylvester(Rule):
         """
         def add_label(L, S, T, m):
             if L.is_empty():
-                assert T.node_number() == 1
+                assert T.number_of_nodes() == 1
                 return LabelledBinaryTree([], m)
             l = L.label()
             if T[0] == S[0]:
@@ -4258,9 +4258,9 @@ class RuleDomino(Rule):
             r"""
             Return the union of the two partitions.
             """
-            return [max(p,q) for (p,q) in zip_longest(la, mu, fillvalue=0)]
+            return [max(p, q) for p, q in zip_longest(la, mu, fillvalue=0)]
 
-        if content not in [0,1,-1]:
+        if content not in [0, 1, -1]:
             raise ValueError("domino: the content of the filling must be in {-1,0,1}")
 
         if content == 1:
@@ -4294,7 +4294,7 @@ class RuleDomino(Rule):
             elif len(diff) == 1:
                 z = copy(x)
                 # diff is a single cell
-                (k,l) = diff.pop()
+                k, l = diff.pop()
                 # add (k+1, l+1) to x
                 # either (k, l+1) or (k+1, l) must also be added
                 if z[k] <= l + 1:

sage/combinat/hall_polynomial.py

@@ -15,7 +15,7 @@ Hall polynomials
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
 from sage.misc.misc_c import prod

sage/combinat/hillman_grassl.py

@@ -569,7 +569,7 @@ def hillman_grassl(M):
                 col_j_hook_mults += [(r, j)] * entry
         hook_mults += reversed(col_j_hook_mults)
     res = [[0] * rowlen for rowlen in lam]
-    for (r, s) in reversed(hook_mults):
+    for r, s in reversed(hook_mults):
         i = r
         j = lam[r] - 1
         while True: