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

sage/algebras/yokonuma_hecke_algebra.py

@@ -276,11 +276,11 @@ class YokonumaHeckeAlgebraGL(YokonumaHeckeAlgebra):
         self._n = n
         W = Permutations(n)
         import itertools
-        C = itertools.product(*([range(d)]*n))
+        C = itertools.product(*([range(d)] * n))
         indices = list(itertools.product(C, W))
         YokonumaHeckeAlgebra.__init__(self, d, W, q, R, indices)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -293,7 +293,7 @@ class YokonumaHeckeAlgebraGL(YokonumaHeckeAlgebra):
         return "Yokonuma-Hecke algebra of rank {} and order {} with q={} over {}".format(
             self._d, self._n, self._q, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -305,7 +305,7 @@ class YokonumaHeckeAlgebraGL(YokonumaHeckeAlgebra):
         """
         return "\\mathcal{Y}_{%s,%s}(%s)" % (self._d, self._n, self._q)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         """
         Return a string representation of the basis element indexed by ``m``.
 
@@ -317,7 +317,8 @@ class YokonumaHeckeAlgebraGL(YokonumaHeckeAlgebra):
         """
         def gen_str(e):
             return '' if e == 1 else '^%s' % e
-        lhs = '*'.join('t%s' % (j+1) + gen_str(i) for j,i in enumerate(m[0]) if i > 0)
+        lhs = '*'.join('t%s' % (j + 1) + gen_str(i)
+                       for j, i in enumerate(m[0]) if i > 0)
         redword = m[1].reduced_word()
         if not redword:
             if not lhs:
@@ -328,7 +329,7 @@ class YokonumaHeckeAlgebraGL(YokonumaHeckeAlgebra):
             return rhs
         return lhs + '*' + rhs
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation for the basis element indexed by ``m``.
 
@@ -340,7 +341,8 @@ class YokonumaHeckeAlgebraGL(YokonumaHeckeAlgebra):
         """
         def gen_str(e):
             return '' if e == 1 else '^{%s}' % e
-        lhs = ' '.join('t_{%s}' % (j+1) + gen_str(i) for j,i in enumerate(m[0]) if i > 0)
+        lhs = ' '.join('t_{%s}' % (j + 1) + gen_str(i)
+                       for j, i in enumerate(m[0]) if i > 0)
         redword = m[1].reduced_word()
         if not redword:
             if not lhs:
@@ -689,7 +691,7 @@ class YokonumaHeckeAlgebraWeyl(YokonumaHeckeAlgebra):
         indices = cartesian_product([self._Q, W])
         YokonumaHeckeAlgebra.__init__(self, d, W, q, R, indices)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -702,7 +704,7 @@ class YokonumaHeckeAlgebraWeyl(YokonumaHeckeAlgebra):
         return "Yokonuma-Hecke algebra of rank {} for {} with q={} over {}".format(
             self._d, self._cartan_type, self._q, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -715,7 +717,7 @@ class YokonumaHeckeAlgebraWeyl(YokonumaHeckeAlgebra):
         from sage.misc.latex import latex
         return "\\mathcal{Y}_{%s,%s}(%s)" % (self._d, latex(self._cartan_type), self._q)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         """
         Return a string representation of the basis element indexed by ``m``.
 
@@ -741,7 +743,7 @@ class YokonumaHeckeAlgebraWeyl(YokonumaHeckeAlgebra):
             return rhs
         return lhs + '*' + rhs
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation for the basis element indexed by ``m``.
 

sage/combinat/all.py

@@ -11,6 +11,15 @@ Introduction
 Topics
 ------
 
+- :ref:`sage.combinat.algebraic_combinatorics`
+
+  - :ref:`sage.combinat.chas.all`
+  - :ref:`sage.combinat.cluster_algebra_quiver.all`
+  - :ref:`sage.combinat.crystals.all`
+  - :ref:`sage.combinat.root_system.all`
+  - :ref:`sage.combinat.sf.all`
+  - :ref:`sage.combinat.fully_commutative_elements`
+
 - :ref:`sage.combinat.counting`
 - :ref:`sage.combinat.enumerated_sets`
 - :ref:`sage.combinat.catalog_partitions`

sage/combinat/all__sagemath_combinat.py

@@ -14,6 +14,7 @@ from sage.combinat.debruijn_sequence import DeBruijnSequences
 
 lazy_import('sage.combinat.schubert_polynomial', 'SchubertPolynomialRing')
 lazy_import('sage.combinat.key_polynomial', 'KeyPolynomialBasis', as_='KeyPolynomials')
+lazy_import('sage.combinat.key_polynomial', 'AtomPolynomialBasis', as_='AtomPolynomials')
 lazy_import('sage.combinat.symmetric_group_algebra', [
             'SymmetricGroupAlgebra', 'HeckeAlgebraSymmetricGroupT'])
 lazy_import('sage.combinat.symmetric_group_representations', [

sage/combinat/alternating_sign_matrix.py

@@ -42,6 +42,7 @@ from sage.structure.parent import Parent
 from sage.structure.element import Element
 from sage.structure.richcmp import richcmp
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.categories.finite_lattice_posets import FiniteLatticePosets
 from sage.matrix.matrix_space import MatrixSpace
 from sage.matrix.constructor import matrix
 from sage.modules.free_module_element import zero_vector
@@ -61,8 +62,8 @@ lazy_import('sage.combinat.posets.lattices', 'LatticePoset')
 
 def _inplace_height_function_gyration(hf):
     k = hf.nrows() - 1
-    for i in range(1,k):
-        for j in range(1,k):
+    for i in range(1, k):
+        for j in range(1, k):
             if (i+j) % 2 == 0 \
                     and hf[i-1,j] == hf[i+1,j] == hf[i,j+1] == hf[i,j-1]:
                 if hf[i,j] < hf[i+1,j]:
@@ -293,7 +294,7 @@ class AlternatingSignMatrix(Element,
         li.reverse()
         return AlternatingSignMatrix(li)
 
-    def inversion_number(self):
+    def number_of_inversions(self):
         r"""
         Return the inversion number of ``self``.
 
@@ -307,27 +308,30 @@ class AlternatingSignMatrix(Element,
         EXAMPLES::
 
             sage: A = AlternatingSignMatrices(3)
-            sage: A([[1, 0, 0],[0, 1, 0],[0, 0, 1]]).inversion_number()
+            sage: A([[1, 0, 0],[0, 1, 0],[0, 0, 1]]).number_of_inversions()
             0
             sage: asm = A([[0, 0, 1],[1, 0, 0],[0, 1, 0]])
-            sage: asm.inversion_number()
+            sage: asm.number_of_inversions()
             2
             sage: asm = A([[0, 1, 0],[1, -1, 1],[0, 1, 0]])
-            sage: asm.inversion_number()
+            sage: asm.number_of_inversions()
             2
             sage: P = Permutations(5)
-            sage: all(p.number_of_inversions()==AlternatingSignMatrix(p.to_matrix()).inversion_number() for p in P)
+            sage: A = AlternatingSignMatrix
+            sage: all(p.number_of_inversions() == A(p.to_matrix()).number_of_inversions() for p in P)
             True
         """
         inversion_num = 0
         asm_matrix = self.to_matrix()
         nonzero_cells = asm_matrix.nonzero_positions()
-        for (i, j) in nonzero_cells:
-            for (k, l) in nonzero_cells:
+        for i, j in nonzero_cells:
+            for k, l in nonzero_cells:
                 if i > k and j < l:
                     inversion_num += asm_matrix[i][j] * asm_matrix[k][l]
         return inversion_num
 
+    inversion_number = number_of_inversions
+
     @combinatorial_map(name='rotate clockwise')
     def rotate_cw(self):
         r"""
@@ -801,11 +805,11 @@ class AlternatingSignMatrix(Element,
             N = len(output)
             for c in range(N):
                 d = copy.copy(output[c])
-                output[c][sign[b][0],sign[b][1]] = -output[c][sign[b][0], sign[b][1]]+1
-                d[sign[b][0],sign[b][1]] = -d[sign[b][0], sign[b][1]]-3
+                output[c][sign[b][0], sign[b][1]] = -output[c][sign[b][0], sign[b][1]]+1
+                d[sign[b][0], sign[b][1]] = -d[sign[b][0], sign[b][1]]-3
                 output.append(d)
         for k in range(len(output)):
-            output[k] = M.from_height_function((output[k]-matrix.ones(n,n))/2)
+            output[k] = M.from_height_function((output[k]-matrix.ones(n, n))/2)
         return output
 
     @combinatorial_map(name='to Dyck word')
@@ -871,7 +875,7 @@ class AlternatingSignMatrix(Element,
 
         raise ValueError("unknown algorithm '%s'" % algorithm)
 
-    def number_negative_ones(self):
+    def number_of_negative_ones(self):
         """
         Return the number of entries in ``self`` equal to -1.
 
@@ -879,16 +883,18 @@ class AlternatingSignMatrix(Element,
 
             sage: A = AlternatingSignMatrices(3)
             sage: asm = A([[0,1,0],[1,0,0],[0,0,1]])
-            sage: asm.number_negative_ones()
+            sage: asm.number_of_negative_ones()
             0
             sage: asm = A([[0,1,0],[1,-1,1],[0,1,0]])
-            sage: asm.number_negative_ones()
+            sage: asm.number_of_negative_ones()
             1
         """
         a = self._matrix
         return ZZ((len(a.nonzero_positions()) - a.nrows()) // 2)
 
-    def is_permutation(self):
+    number_negative_ones = number_of_negative_ones
+
+    def is_permutation(self) -> bool:
         """
         Return ``True`` if ``self`` is a permutation matrix
         and ``False`` otherwise.
@@ -903,7 +909,7 @@ class AlternatingSignMatrix(Element,
             sage: asm.is_permutation()
             False
         """
-        return self.number_negative_ones() == 0
+        return self.number_of_negative_ones() == 0
 
     def to_permutation(self):
         """
@@ -927,7 +933,7 @@ class AlternatingSignMatrix(Element,
         if not self.is_permutation():
             raise ValueError('not a permutation matrix')
         asm_matrix = self.to_matrix()
-        return Permutation([j + 1 for (i, j) in asm_matrix.nonzero_positions()])
+        return Permutation([j + 1 for _, j in asm_matrix.nonzero_positions()])
 
     @combinatorial_map(name='to semistandard tableau')
     def to_semistandard_tableau(self):
@@ -1044,10 +1050,10 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         sage: L = A.lattice(); L
         Finite lattice containing 7 elements
         sage: L.category()
-        Category of facade finite enumerated lattice posets
+        Category of facade finite enumerated distributive lattices
     """
 
-    def __init__(self, n):
+    def __init__(self, n) -> None:
         r"""
         Initialize ``self``.
 
@@ -1060,7 +1066,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         self._matrix_space = MatrixSpace(ZZ, n)
         Parent.__init__(self, category=FiniteEnumeratedSets())
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -1085,7 +1091,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         """
         return self._matrix_space._repr_option(key)
 
-    def __contains__(self, asm):
+    def __contains__(self, asm) -> bool:
         """
         Check if ``asm`` is in ``self``.
 
@@ -1242,7 +1248,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
             [ 0  0  0  1  0  0  0]
             [ 0  1  0  0  0  0  0]
             sage: a = AlternatingSignMatrices(5).random_element()
-            sage: bool(a.number_negative_ones()) or a.is_permutation()
+            sage: bool(a.number_of_negative_ones()) or a.is_permutation()
             True
 
         This is done using a modified version of Propp and Wilson's "coupling
@@ -1472,7 +1478,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         m.set_immutable()
         return self.element_class(self, m)
 
-    def _lattice_initializer(self):
+    def _lattice_initializer(self) -> tuple:
         r"""
         Return a 2-tuple to use in argument of ``LatticePoset``.
 
@@ -1494,7 +1500,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         """
         mts, rels = MonotoneTriangles(self._n)._lattice_initializer()
         bij = {t: self.from_monotone_triangle(t) for t in mts}
-        return (bij.values(), [(bij[a], bij[b]) for (a, b) in rels])
+        return (bij.values(), [(bij[a], bij[b]) for a, b in rels])
 
     def cover_relations(self):
         r"""
@@ -1504,7 +1510,7 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
         EXAMPLES::
 
             sage: A = AlternatingSignMatrices(3)
-            sage: for (a,b) in A.cover_relations():
+            sage: for a, b in A.cover_relations():
             ....:   eval('a, b')
             (
             [1 0 0]  [0 1 0]
@@ -1560,8 +1566,9 @@ class AlternatingSignMatrices(UniqueRepresentation, Parent):
             sage: L = A.lattice(); L                                                    # needs sage.graphs
             Finite lattice containing 7 elements
         """
+        cat = FiniteLatticePosets().Distributive()
         return LatticePoset(self._lattice_initializer(), cover_relations=True,
-                            check=False)
+                            check=False, category=cat)
 
     @cached_method
     def gyration_orbits(self):
@@ -1736,7 +1743,7 @@ class MonotoneTriangles(GelfandTsetlinPatternsTopRow):
         EXAMPLES::
 
             sage: M = MonotoneTriangles(3)
-            sage: for (a,b) in M.cover_relations():
+            sage: for a, b in M.cover_relations():
             ....:   eval('a, b')
             ([[3, 2, 1], [2, 1], [1]], [[3, 2, 1], [2, 1], [2]])
             ([[3, 2, 1], [2, 1], [1]], [[3, 2, 1], [3, 1], [1]])
@@ -1780,7 +1787,7 @@ def _is_a_cover(mt0, mt1):
         False
     """
     diffs = 0
-    for (a, b) in zip(flatten(mt0), flatten(mt1)):
+    for a, b in zip(flatten(mt0), flatten(mt1)):
         if a != b:
             if a + 1 == b:
                 diffs += 1

sage/combinat/baxter_permutations.py

@@ -2,7 +2,10 @@
 """
 Baxter permutations
 """
+from collections.abc import Iterator
+
 from sage.combinat.permutation import Permutations
+from sage.combinat.posets.lattices import LatticePoset
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
 from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
@@ -69,8 +72,7 @@ class BaxterPermutations_size(BaxterPermutations):
         sage: BaxterPermutations_size(5)
         Baxter permutations of size 5
     """
-
-    def __init__(self, n):
+    def __init__(self, n) -> None:
         """
         EXAMPLES::
 
@@ -146,7 +148,7 @@ class BaxterPermutations_size(BaxterPermutations):
                     return False
         return True
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator:
         r"""
         Efficient generation of Baxter permutations.
 
@@ -235,6 +237,24 @@ class BaxterPermutations_size(BaxterPermutations):
                     n.binomial(k + 2)) // (n * n.binomial(2))
                    for k in range(self._n))
 
+    def lattice(self):
+        """
+        Return the lattice of Baxter permutations.
+
+        This is defined by restriction of the weak order.
+
+        EXAMPLES::
+
+            sage: L = BaxterPermutations(4).lattice(); L
+            Finite lattice containing 22 elements
+
+        REFERENCES:
+
+        - [Law2011]_
+        """
+        return LatticePoset([list(self), lambda a, b: a.weak_le(b)],
+                            check=False)
+
 
 class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
     r"""
@@ -249,8 +269,7 @@ class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
         sage: BaxterPermutations_all()
         Baxter permutations
     """
-
-    def __init__(self, n=None):
+    def __init__(self, n=None) -> None:
         r"""
         EXAMPLES::
 
@@ -259,14 +278,14 @@ class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
             Baxter permutations
         """
         self.element_class = Permutations().element_class
-        from sage.sets.non_negative_integers import NonNegativeIntegers
         from sage.sets.family import Family
+        from sage.sets.non_negative_integers import NonNegativeIntegers
         DisjointUnionEnumeratedSets.__init__(self,
                                              Family(NonNegativeIntegers(),
                                                     BaxterPermutations_size),
                                              facade=False, keepkey=False)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -278,7 +297,7 @@ class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
         """
         return "Baxter permutations"
 
-    def __contains__(self, x):
+    def __contains__(self, x) -> bool:
         r"""
         Return ``True`` if and only if ``x`` is a Baxter permutation.
 
@@ -302,7 +321,7 @@ class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
             return False
         return x in BaxterPermutations(len(x))
 
-    def to_pair_of_twin_binary_trees(self, p):
+    def to_pair_of_twin_binary_trees(self, p) -> tuple:
         r"""
         Apply a bijection between Baxter permutations of size ``self._n``
         and the set of pairs of twin binary trees with ``self._n`` nodes.
@@ -328,12 +347,13 @@ class BaxterPermutations_all(DisjointUnionEnumeratedSets, BaxterPermutations):
 
         EXAMPLES::
 
+            sage: # needs sage.graphs
             sage: BP = BaxterPermutations()
-            sage: BP.to_pair_of_twin_binary_trees(Permutation([]))                      # needs sage.graphs
+            sage: BP.to_pair_of_twin_binary_trees(Permutation([]))
             (., .)
-            sage: BP.to_pair_of_twin_binary_trees(Permutation([1, 2, 3]))               # needs sage.graphs
+            sage: BP.to_pair_of_twin_binary_trees(Permutation([1, 2, 3]))
             (1[., 2[., 3[., .]]], 3[2[1[., .], .], .])
-            sage: BP.to_pair_of_twin_binary_trees(Permutation([3, 4, 1, 2]))            # needs sage.graphs
+            sage: BP.to_pair_of_twin_binary_trees(Permutation([3, 4, 1, 2]))
             (3[1[., 2[., .]], 4[., .]], 2[1[., .], 4[3[., .], .]])
         """
         from sage.combinat.binary_tree import LabelledBinaryTree

sage/combinat/bijectionist.py

@@ -60,7 +60,7 @@ check this for permutations of size at most `3`::
     sage: def alpha1(p): return len(p.weak_excedences())
     sage: def alpha2(p): return len(p.fixed_points())
     sage: def beta1(p): return len(p.descents(final_descent=True)) if p else 0
-    sage: def beta2(p): return len([e for (e, f) in zip(p, p[1:]+[0]) if e == f+1])
+    sage: def beta2(p): return len([e for e, f in zip(p, p[1:]+[0]) if e == f+1])
     sage: tau = Permutation.longest_increasing_subsequence_length
     sage: def rotate_permutation(p):
     ....:     cycle = Permutation(tuple(range(1, len(p)+1)))
@@ -157,14 +157,14 @@ following code is equivalent to ``tau = findstat(397)``::
     ....:         else:
     ....:             return m+1
     sage: bij = Bijectionist(A, B, tau)
-    sage: bij.set_statistics((lambda a: a.size(), lambda b: b.node_number()-1))
+    sage: bij.set_statistics((lambda a: a.size(), lambda b: b.number_of_nodes()-1))
     sage: from sage.combinat.cyclic_sieving_phenomenon import orbit_decomposition
     sage: bij.set_constant_blocks(orbit_decomposition(A, theta))
     sage: list(bij.solutions_iterator())
     []
 
-Next we demonstrate how to search for a bijection, instead An example
-identifying `s` and `S`::
+Next we demonstrate how to search for a bijection.  To do so, we identify `s`
+and `S`::
 
     sage: N = 4
     sage: A = [dyck_word for n in range(1, N) for dyck_word in DyckWords(n)]
@@ -174,7 +174,7 @@ identifying `s` and `S`::
     ....:                                          B2.to_dyck_word()).to_binary_tree()
     sage: bij = Bijectionist(A, B)
     sage: bij.set_intertwining_relations((2, concat_path, concat_tree))
-    sage: bij.set_statistics((lambda d: d.semilength(), lambda t: t.node_number()))
+    sage: bij.set_statistics((lambda d: d.semilength(), lambda t: t.number_of_nodes()))
     sage: for D in sorted(bij.minimal_subdistributions_iterator(), key=lambda x: (len(x[0][0]), x)):
     ....:     ascii_art(D)
     ( [ /\ ], [ o ] )
@@ -691,7 +691,7 @@ class Bijectionist(SageObject):
             sage: def wex(p): return len(p.weak_excedences())
             sage: def fix(p): return len(p.fixed_points())
             sage: def des(p): return len(p.descents(final_descent=True)) if p else 0
-            sage: def adj(p): return len([e for (e, f) in zip(p, p[1:]+[0]) if e == f+1])
+            sage: def adj(p): return len([e for e, f in zip(p, p[1:]+[0]) if e == f+1])
             sage: bij = Bijectionist(A, B, fix)
             sage: bij.set_statistics((wex, des), (len, len))
             sage: for solution in sorted(list(bij.solutions_iterator()), key=lambda d: tuple(sorted(d.items()))):
@@ -801,7 +801,7 @@ class Bijectionist(SageObject):
             sage: def wex(p): return len(p.weak_excedences())
             sage: def fix(p): return len(p.fixed_points())
             sage: def des(p): return len(p.descents(final_descent=True)) if p else 0
-            sage: def adj(p): return len([e for (e, f) in zip(p, p[1:]+[0]) if e == f+1])
+            sage: def adj(p): return len([e for e, f in zip(p, p[1:]+[0]) if e == f+1])
             sage: bij = Bijectionist(A, B, tau)
             sage: bij.set_statistics((len, len), (wex, des), (fix, adj))
             sage: table([[key, AB[0], AB[1]] for key, AB in bij.statistics_fibers().items()])
@@ -845,7 +845,7 @@ class Bijectionist(SageObject):
             sage: def wex(p): return len(p.weak_excedences())
             sage: def fix(p): return len(p.fixed_points())
             sage: def des(p): return len(p.descents(final_descent=True)) if p else 0
-            sage: def adj(p): return len([e for (e, f) in zip(p, p[1:]+[0]) if e == f+1])
+            sage: def adj(p): return len([e for e, f in zip(p, p[1:]+[0]) if e == f+1])
             sage: bij = Bijectionist(A, B, tau)
             sage: bij.set_statistics((wex, des), (fix, adj))
             sage: a, b = bij.statistics_table()
@@ -1554,7 +1554,7 @@ class Bijectionist(SageObject):
             sage: def alpha1(p): return len(p.weak_excedences())
             sage: def alpha2(p): return len(p.fixed_points())
             sage: def beta1(p): return len(p.descents(final_descent=True)) if p else 0
-            sage: def beta2(p): return len([e for (e, f) in zip(p, p[1:] + [0]) if e == f + 1])
+            sage: def beta2(p): return len([e for e, f in zip(p, p[1:] + [0]) if e == f + 1])
             sage: tau = Permutation.longest_increasing_subsequence_length
             sage: def rotate_permutation(p):
             ....:    cycle = Permutation(tuple(range(1, len(p) + 1)))
@@ -2763,13 +2763,9 @@ class _BijectionistMILP:
                        coeff * values[index_block_value_dict[index]]
                        for index, coeff in f.dict().items())
 
-        for lhs, rhs in constraint.equations():
-            if evaluate(lhs - rhs):
-                return False
-        for lhs, rhs in constraint.inequalities():
-            if evaluate(lhs - rhs) > 0:
-                return False
-        return True
+        if any(evaluate(lhs - rhs) for lhs, rhs in constraint.equations()):
+            return False
+        return all(evaluate(lhs - rhs) <= 0 for lhs, rhs in constraint.inequalities())
 
     def add_alpha_beta_constraints(self):
         r"""
@@ -3174,7 +3170,7 @@ Our benchmark example::
     sage: def alpha1(p): return len(p.weak_excedences())
     sage: def alpha2(p): return len(p.fixed_points())
     sage: def beta1(p): return len(p.descents(final_descent=True)) if p else 0
-    sage: def beta2(p): return len([e for (e, f) in zip(p, p[1:]+[0]) if e == f+1])
+    sage: def beta2(p): return len([e for e, f in zip(p, p[1:]+[0]) if e == f+1])
     sage: gamma = Permutation.longest_increasing_subsequence_length
     sage: def rotate_permutation(p):
     ....:    cycle = Permutation(tuple(range(1, len(p)+1)))

sage/combinat/chas/fsym.py

@@ -328,7 +328,7 @@ class FSymBases(Category_realization_of_parent):
 
                 sage: z = G[[1,3,5],[2,4]]
                 sage: all(F.duality_pairing(F[p1] * F[p2], z) == c
-                ....:     for ((p1, p2), c) in z.coproduct())
+                ....:     for (p1, p2), c in z.coproduct())
                 True
 
             TESTS:
@@ -342,7 +342,7 @@ class FSymBases(Category_realization_of_parent):
                 Rational Field
             """
             y = self.dual_basis()(y)
-            return self.base_ring().sum(coeff * y[t] for (t, coeff) in x)
+            return self.base_ring().sum(coeff * y[t] for t, coeff in x)
 
         def duality_pairing_matrix(self, basis, degree):
             r"""
@@ -496,7 +496,7 @@ class FreeSymmetricFunctions(UniqueRepresentation, Parent):
         cat = HopfAlgebras(base_ring).Graded().Connected()
         Parent.__init__(self, base=base_ring, category=cat.WithRealizations())
 
-    _shorthands = ['G']
+    _shorthands = ('G',)
 
     def a_realization(self):
         r"""
@@ -791,7 +791,7 @@ class FreeSymmetricFunctions_Dual(UniqueRepresentation, Parent):
         sage: TF(F[[5, 1, 4, 2, 3]])
         F[135|2|4]
     """
-    def __init__(self, base_ring):
+    def __init__(self, base_ring) -> None:
         r"""
         Initialize ``self``.
 
@@ -803,7 +803,7 @@ class FreeSymmetricFunctions_Dual(UniqueRepresentation, Parent):
         cat = HopfAlgebras(base_ring).Graded().Connected()
         Parent.__init__(self, base=base_ring, category=cat.WithRealizations())
 
-    _shorthands = ['F']
+    _shorthands = ('F',)
 
     def a_realization(self):
         r"""
@@ -1114,7 +1114,7 @@ def ascent_set(t):
         [2, 4, 5]
     """
     row_locations = {}
-    for (i, row) in enumerate(t):
+    for i, row in enumerate(t):
         for entry in row:
             row_locations[entry] = i
     n = len(row_locations)