gh-40817: some details about imports in combinat
    
just a few minor suggestions by `ruff` in the combinat folder

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: #40817
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Martin Rubey

Author: Release Manager

src/sage/combinat/colored_permutations.py

@@ -22,7 +22,7 @@
 from sage.combinat.permutation import Permutations
 from sage.combinat.free_module import CombinatorialFreeModule
 from sage.combinat.specht_module import SpechtModule as SymGroupSpechtModule
-from sage.combinat.partition_tuple import PartitionTuples, PartitionTuple
+from sage.combinat.partition_tuple import PartitionTuples
 from sage.groups.conjugacy_classes import ConjugacyClass
 from sage.modules.with_basis.subquotient import SubmoduleWithBasis, QuotientModuleWithBasis
 from sage.modules.with_basis.representation import Representation_abstract
@@ -280,7 +280,7 @@ def to_matrix(self):
         """
         Cp = CyclotomicField(self.parent()._m)
         g = Cp.gen()
-        D = diagonal_matrix(Cp, [g ** i for i in self._colors])
+        D = diagonal_matrix(Cp, [g**i for i in self._colors])
         return self._perm.to_matrix() * D
 
     def has_left_descent(self, i) -> bool:
@@ -478,7 +478,7 @@ def __classcall_private__(cls, m, p, n):
             return ColoredPermutations(m, n)
         return super().__classcall__(cls, m, p, n)
 
-    def __init__(self, m, p, n):
+    def __init__(self, m, p, n) -> None:
         r"""
         Initialize ``self``.
 
@@ -509,9 +509,7 @@ def __init__(self, m, p, n):
         self._C = IntegerModRing(self._m)
         self._P = Permutations(self._n)
 
-        if (self._p == 1 and (self._m == 1 or self._m == 2)
-            or (self._p == 2 and self._m == 2)
-            or (self._n == 2 and self._p == self._m)):
+        if self._p <= self._m <= 2 or (self._n == 2 and self._p == self._m):
             from sage.categories.finite_coxeter_groups import FiniteCoxeterGroups
             category = FiniteCoxeterGroups()
             if not (self._n == self._m == self._p == 2):  # special case of type D_2
@@ -523,7 +521,7 @@ def __init__(self, m, p, n):
                 category = category.WellGenerated()
         Parent.__init__(self, category=category)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -743,8 +741,8 @@ def simple_reflection(self, i):
         if i == self._n + 1 or self._n == 1:
             return sn ** self._p
 
-        snm = self.simple_reflection(self._n-1)
-        return sn**(self._m-1) * snm * sn
+        snm = self.simple_reflection(self._n - 1)
+        return sn**(self._m - 1) * snm * sn
 
     @cached_method
     def _inverse_simple_reflections(self):
@@ -2227,7 +2225,7 @@ def __init__(self, G, base_ring, diagram):
         data = [cartesian_product([OrderedSetPartitions([val * x for x, val in zip(sorted(X), signs)], la),
                                    OrderedSetPartitions(sorted(Y), mu)])
                 for (X, Y) in OrderedSetPartitions(G._n, [sum(la), sum(mu)])
-                for signs in product([1,-1], repeat=sum(la))]
+                for signs in product([1, -1], repeat=sum(la))]
         tabloids = DisjointUnionEnumeratedSets(data)
         tabloids.rename(f"Tabloids of shape {self._diagram}")
 
@@ -2527,8 +2525,8 @@ def group_elements(sigma):
                 n = T.size()
                 for sigma in T.column_stabilizer():
                     sigma = sigma.tuple()
-                    for signs in product(*[[1,-1] if i not in mu_vals else [1]
-                                           for i in range(1,n+1)]):
+                    for signs in product(*[[1, -1] if i not in mu_vals else [1]
+                                           for i in range(1, n+1)]):
                         yield self._semigroup([s * val for s, val in zip(signs, sigma)])
 
             return ambient.sum_of_terms((ambient._semigroup_basis_action(elt, tab),
@@ -2922,7 +2920,7 @@ class SimpleModule(Representation_abstract, QuotientModuleWithBasis):
         [0 0 0 0 0 0 1 0]
         [0 0 0 0 0 0 0 1]
     """
-    def __init__(self, specht_module):
+    def __init__(self, specht_module) -> None:
         r"""
         Initialize ``self``.
 
@@ -2932,18 +2930,19 @@ def __init__(self, specht_module):
             sage: D = B4.simple_module([[2,1], [1]], GF(3))
             sage: TestSuite(D).run()
         """
-        self._diagram = specht_module._diagram
         p = specht_module.base_ring().characteristic()
-        if (not all(la.is_regular(p) for la in specht_module._diagram)
-            or (p == 2 and specht_module._diagram[0])):
+        d = self._diagram = specht_module._diagram
+        if (p == 2 and d[0]) or not all(la.is_regular(p) for la in d):
             raise ValueError(f"the partition must be {p}-regular")
-        Representation_abstract.__init__(self, specht_module._semigroup, specht_module._side,
+        Representation_abstract.__init__(self, specht_module._semigroup,
+                                         specht_module._side,
                                          algebra=specht_module._semigroup_algebra)
         cat = specht_module.category()
-        QuotientModuleWithBasis.__init__(self, specht_module.maximal_submodule(),
+        QuotientModuleWithBasis.__init__(self,
+                                         specht_module.maximal_submodule(),
                                          cat, prefix='D', bracket='')
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -2955,7 +2954,7 @@ def _repr_(self):
         """
         return f"Simple module of {self._diagram} over {self.base_ring()}"
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 

src/sage/combinat/crystals/infinity_crystals.py

@@ -11,7 +11,7 @@
 - Travis Scrimshaw: initial version
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2013 Ben Salisbury <bsalisbury1 at gmail.com>
 #                          Travis Scrimshaw <tscrim at ucdavis.edu>
 #
@@ -24,13 +24,12 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#****************************************************************************
+#                  https://www.gnu.org/licenses/
+# **************************************************************************
 
 from sage.structure.parent import Parent
 from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
 from sage.categories.highest_weight_crystals import HighestWeightCrystals
-from sage.categories.crystals import Crystals
 from sage.categories.supercrystals import SuperCrystals
 from sage.categories.homset import Hom
 from sage.misc.cachefunc import cached_method
@@ -40,9 +39,10 @@
 from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.crystals.letters import CrystalOfLetters
 from sage.combinat.crystals.tensor_product import CrystalOfWords
-from sage.combinat.crystals.tensor_product_element import (CrystalOfTableauxElement,
-        InfinityCrystalOfTableauxElement, InfinityCrystalOfTableauxElementTypeD,
-        InfinityQueerCrystalOfTableauxElement)
+from sage.combinat.crystals.tensor_product_element import (
+    CrystalOfTableauxElement,
+    InfinityCrystalOfTableauxElement, InfinityCrystalOfTableauxElementTypeD,
+    InfinityQueerCrystalOfTableauxElement)
 
 
 class InfinityCrystalOfTableaux(CrystalOfWords):
@@ -502,28 +502,28 @@ def seg(self):
             for r in range(len(tab)):
                 for c in range(len(tab[r])):
                     if tab[r][c] != r+1:
-                        if [r,tab[r][c]] not in segments:
-                            segments.append([r,tab[r][c]])
+                        if [r, tab[r][c]] not in segments:
+                            segments.append([r, tab[r][c]])
             if self.parent().cartan_type().type() == 'B':
                 for r in range(len(tab)):
                     for c in range(len(tab[r])):
                         if tab[r][c] == 0 and tab[r][-1] == -r-1:
-                            segments.remove([r,tab[r][c]])
+                            segments.remove([r, tab[r][c]])
             if self.parent().cartan_type().type() == 'D':
                 n = self.parent().cartan_type().rank()
                 add = []
                 for r in range(len(tab)):
                     if tab[r][-1] == -1*(r+1):
                         for c in range(len(tab[r])):
                             if tab[r][c] != n and tab[r][c] != -n:
-                                if [r,n] not in add:
-                                    add.append([r,n])
+                                if [r, n] not in add:
+                                    add.append([r, n])
                 if len(add) > 0:
-                    segments.append([r,n])
+                    segments.append([r, n])
             if self.parent().cartan_type().type() == 'G':
                 for c in range(len(tab[0])):
                     if tab[0][c] == 0 and tab[0][-1] == -1:
-                        segments.remove([0,tab[0][c]])
+                        segments.remove([0, tab[0][c]])
             return len(segments)
 
         def content(self):
@@ -556,11 +556,11 @@ def content(self):
             tab = self.to_tableau()
             count = 0
             ct = self.parent().cartan_type().type()
-            for i,row in enumerate(tab):
+            for i, row in enumerate(tab):
                 for entry in row:
-                    if entry == -i-1 and ct in ('B', 'D', 'G'):
+                    if entry == -i - 1 and ct in ('B', 'D', 'G'):
                         count += 2
-                    elif entry != i+1:
+                    elif entry != i + 1:
                         count += 1
             return count
 
@@ -636,7 +636,7 @@ class Element(InfinityCrystalOfTableauxElementTypeD, InfinityCrystalOfTableaux.E
 
 
 #########################################################
-## Queer superalgebra
+#  Queer superalgebra
 
 class DualInfinityQueerCrystalOfTableaux(CrystalOfWords):
     @staticmethod

src/sage/combinat/diagram_algebras.py

@@ -4491,7 +4491,6 @@ def cellular_involution(self, x):
                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)
 

src/sage/combinat/fully_commutative_elements.py

@@ -28,8 +28,6 @@
 # (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

src/sage/combinat/regular_sequence_bounded.py

@@ -26,15 +26,15 @@
 - Gabriel Lipnik is supported by the
   Austrian Science Fund (FWF): P 24644-N26.
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2017 Gabriel Lipnik <[email protected]>
 #
 # This program is free software: You can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 
 def multiply_reduce(A, B):
@@ -75,7 +75,7 @@ def multiply_reduce(A, B):
         [ -8 -14 -20]
         [  2   2   2]
     """
-    return (A*B).apply_map(lambda m: min(m, 2))
+    return (A * B).apply_map(lambda m: min(m, 2))
 
 
 def construct_phi(matrices):
@@ -144,7 +144,6 @@ def construct_phi(matrices):
         [2 2 2], [0 2 0], [0 2 2], [1 1 2], [2 0 0], [2 2 2], [1 2 2]
         ]
     """
-    from sage.arith.srange import srange
     length = len(matrices)
 
     def get_immutable(M):
@@ -389,7 +388,6 @@ def make_positive(matrices) -> list:
         ...
         ValueError: There is a matrix which is neither non-negative nor non-positive.
     """
-    from sage.arith.srange import srange
 
     def do(mat):
         if is_non_negative(mat):
@@ -513,10 +511,7 @@ def regular_sequence_is_bounded(S):
         sage: regular_sequence_is_bounded(S)
         True
     """
-    from sage.arith.srange import srange
-
     matrices = list(S.mu)
-    length = len(matrices)
     try:
         return is_bounded_via_mandel_simon_algorithm(make_positive(matrices))
     except ValueError:
@@ -526,7 +521,7 @@ def regular_sequence_is_bounded(S):
     if not has_bounded_matrix_powers(matrices):
         return False
 
-    matricesProd = list(ell*em for ell in matrices for em in matrices
+    matricesProd = list(ell * em for ell in matrices for em in matrices
                         if ell != em)
     if not has_bounded_matrix_powers(matricesProd):
         return False

src/sage/combinat/symmetric_group_algebra.py

@@ -2176,7 +2176,6 @@ def _dft_unitary(self):
             ...
             NotImplementedError: not implemented when p|n!; dimension of invariant forms may be greater than one
         """
-        from sage.matrix.special import diagonal_matrix
         F = self.base_ring()
         G = self.group()
 
@@ -2209,9 +2208,9 @@ def conj_square_root(u):
                 return F.zero()
             z = F.multiplicative_generator()
             k = u.log(z)
-            if k % (q+1) != 0:
+            if k % (q + 1) != 0:
                 raise ValueError(f"unable to factor as {u} is not in base field GF({q})")
-            return z ** ((k//(q+1)) % (q-1))
+            return z ** ((k // (q + 1)) % (q - 1))
 
         dft_matrix = self.dft()
         n = dft_matrix.nrows()
@@ -2536,7 +2535,7 @@ def _column_antistabilizer(self, la):
         T = []
         total = 1  # make it 1-based
         for r in la:
-            T.append(list(range(total, total+r)))
+            T.append(list(range(total, total + r)))
             total += r
         T = Tableau(T)
         G = self.group()
@@ -2634,7 +2633,7 @@ def kazhdan_lusztig_basis_element(self, w):
             self._cellular_KL = KazhdanLusztigPolynomial(self._KLG, q)
             polyfunc = self._cellular_KL.P
         else:
-            self._cellular_KL = Coxeter3Group(['A', self.n+1])
+            self._cellular_KL = Coxeter3Group(['A', self.n + 1])
             self._KLG = self._cellular_KL
             polyfunc = self._cellular_KL.kazhdan_lusztig_polynomial
 
@@ -3565,9 +3564,9 @@ def _element_constructor_(self, x):
         if x in Permutations():
             if len(x) < self.n:
                 return self.monomial(self._indices(
-                            list(x) + list(range(len(x) + 1, self.n + 1))
-                        ))
-            if all(x[i] == i+1 for i in range(self.n, len(x))):
+                    list(x) + list(range(len(x) + 1, self.n + 1))
+                ))
+            if all(x[i] == i + 1 for i in range(self.n, len(x))):
                 return self.monomial(self._indices(x[:self.n]))
 
         return self._indices(x)