gh-36335: using more itertools.product
    
a few more cases where one can use itertools.product instead of our
custom iterator

### 📝 Checklist

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

Author: Release Manager

src/sage/combinat/multiset_partition_into_sets_ordered.py

@@ -52,22 +52,19 @@
      ((1,), (1, 2, 3)), ((1, 2), (2, 3)), ((1, 2, 3), (3,))]
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2018 Aaron Lauve       <lauve at math.luc.edu>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ****************************************************************************
-
-
 from functools import reduce
-from itertools import chain
+from itertools import chain, product
 
 from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
-from sage.categories.cartesian_product import cartesian_product
 from sage.categories.classical_crystals import ClassicalCrystals
 from sage.categories.tensor import tensor
 from sage.structure.unique_representation import UniqueRepresentation
@@ -672,7 +669,7 @@ def split_blocks(self, k=2):
             return {tuple([self]*k): 1}
 
         out = {}
-        for t in cartesian_product([_split_block(block, k) for block in self]):
+        for t in product(*[_split_block(block, k) for block in self]):
             tt = tuple([P([l for l in c if l]) for c in zip(*t)])
             out[tt] = out.get(tt, 0) + 1
         return out
@@ -711,8 +708,8 @@ def finer(self, strong=False):
         if not self:
             return set([self])
 
-        CP = cartesian_product([_refine_block(block, strong) for block in self])
-        return set(P(_concatenate(map(list,c))) for c in CP)
+        CP = product(*[_refine_block(block, strong) for block in self])
+        return set(P(_concatenate(map(list, c))) for c in CP)
 
     def is_finer(self, co):
         """
@@ -2892,16 +2889,16 @@ def _iterator_size(size, length=None, alphabet=None):
         max_p = max(alphabet)
         for alpha in IntegerListsLex(size, length=length, min_part=1,
                                      max_part=min(size, sum(alphabet))):
-            for p in cartesian_product([IntegerListsLex(a, min_slope=1,
-                                                        min_part=min_p,
-                                                        max_part=min(a, max_p))
-                                        for a in alpha]):
+            for p in product(*[IntegerListsLex(a, min_slope=1,
+                                               min_part=min_p,
+                                               max_part=min(a, max_p))
+                               for a in alpha]):
                 if frozenset(_concatenate(p)).issubset(frozenset(alphabet)):
                     yield tuple(frozenset(k) for k in p)
     else:
         for alpha in IntegerListsLex(size, length=length, min_part=1, max_part=size):
-            for p in cartesian_product([IntegerListsLex(a, min_slope=1,
-                                                        min_part=1) for a in alpha]):
+            for p in product(*[IntegerListsLex(a, min_slope=1,
+                                               min_part=1) for a in alpha]):
                 yield tuple(frozenset(k) for k in p)
 
 
@@ -2967,11 +2964,11 @@ def _iterator_order(A, d, lengths=None):
             yield ()
         else:
             for alpha in IntegerListsLex(d, length=k, min_part=1, max_part=n):
-                for co in cartesian_product([Subsets_sk(A, a) for a in alpha]):
+                for co in product(*[Subsets_sk(A, a) for a in alpha]):
                     yield tuple(frozenset(X) for X in co)
 
 
-def _descents(w):
+def _descents(w) -> list:
     r"""
     Return descent positions in the word ``w``.
 
@@ -2983,7 +2980,7 @@ def _descents(w):
         sage: _descents([])
         []
     """
-    return [j for j in range(len(w)-1) if w[j] > w[j+1]]
+    return [j for j in range(len(w) - 1) if w[j] > w[j + 1]]
 
 
 def _break_at_descents(alpha, weak=True):

src/sage/combinat/set_partition_ordered.py

@@ -24,8 +24,9 @@
 #
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from itertools import product
+
 from sage.arith.misc import factorial, multinomial
-from sage.categories.cartesian_product import cartesian_product
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
 from sage.combinat.combinat import stirling_number2
@@ -452,7 +453,7 @@ def finer(self):
         if not self:
             return FiniteEnumeratedSet([self])
         return FiniteEnumeratedSet([par(sum((list(i) for i in C), []))
-                                    for C in cartesian_product([OrderedSetPartitions(X) for X in self])])
+                                    for C in product(*[OrderedSetPartitions(X) for X in self])])
 
     def is_finer(self, co2):
         """
@@ -548,7 +549,7 @@ def fatten(self, grouping):
         result = [None] * len(grouping)
         j = 0
         for i in range(len(grouping)):
-            result[i] = set().union(*self[j:j+grouping[i]])
+            result[i] = set().union(*self[j:j + grouping[i]])
             j += grouping[i]
         return parent(self)(result)
 
@@ -636,7 +637,7 @@ def bottom_up_osp(X, comp):
         result = [None] * len(comp)
         j = 0
         for i in range(len(comp)):
-            result[i] = set(xs[j:j+comp[i]])
+            result[i] = set(xs[j:j + comp[i]])
             j += comp[i]
         return OrderedSetPartitions(X)(result)
 
@@ -671,7 +672,7 @@ def strongly_finer(self):
             return FiniteEnumeratedSet([self])
         buo = OrderedSetPartition.bottom_up_osp
         return FiniteEnumeratedSet([par(sum((list(P) for P in C), []))
-                                    for C in cartesian_product([[buo(X, comp) for comp in Compositions(len(X))] for X in self])])
+                                    for C in product(*[[buo(X, comp) for comp in Compositions(len(X))] for X in self])])
 
     def is_strongly_finer(self, co2):
         r"""
@@ -779,7 +780,7 @@ def strongly_fatter(self):
         # arbitrarily, and then concatenate the results.
         fattenings = [list(subcomp.fatter()) for subcomp in subcomps]
         return FiniteEnumeratedSet([OrderedSetPartition(sum([list(gg) for gg in fattening], []))
-            for fattening in cartesian_product(fattenings)])
+            for fattening in product(*fattenings)])
 
     @combinatorial_map(name='to packed word')
     def to_packed_word(self):

src/sage/graphs/path_enumeration.pyx

@@ -31,8 +31,8 @@ Functions
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from itertools import product
 
-from sage.categories.cartesian_product import cartesian_product
 from sage.misc.misc_c import prod
 from libcpp.queue cimport priority_queue
 from libcpp.pair cimport pair
@@ -263,7 +263,7 @@ def all_paths(G, start, end, use_multiedges=False, report_edges=False, labels=Fa
     if report_edges and labels:
         path_with_labels = []
         for p in all_paths:
-            path_with_labels.extend(cartesian_product([edge_labels[e] for e in zip(p[:-1], p[1:])]))
+            path_with_labels.extend(product(*[edge_labels[e] for e in zip(p[:-1], p[1:])]))
         return path_with_labels
     elif use_multiedges and G.has_multiple_edges():
         multiple_all_paths = []
@@ -1586,7 +1586,7 @@ def _all_paths_iterator(self, vertex, ending_vertices=None,
                           neighbor in ending_vertices):
                         newpath = path + [neighbor]
                         if report_edges and labels:
-                            for p in cartesian_product([my_dict[e] for e in zip(newpath[:-1], newpath[1:])]):
+                            for p in product(*[my_dict[e] for e in zip(newpath[:-1], newpath[1:])]):
                                 yield list(p)
                         elif use_multiedges and self.has_multiple_edges():
                             m = prod(edge_multiplicity[e] for e in zip(newpath[:-1], newpath[1:]))
@@ -1610,7 +1610,7 @@ def _all_paths_iterator(self, vertex, ending_vertices=None,
         if path[-1] in ending_vertices:
             # yield good path
             if report_edges and labels:
-                for p in cartesian_product([my_dict[e] for e in zip(path[:-1], path[1:])]):
+                for p in product(*[my_dict[e] for e in zip(path[:-1], path[1:])]):
                     yield list(p)
             elif use_multiedges and self.has_multiple_edges():
                 m = prod(edge_multiplicity[e] for e in zip(path[:-1], path[1:]))

src/sage/modules/filtered_vector_space.py

@@ -107,6 +107,7 @@
 #  the License, or (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ***************************************************************************
+from itertools import product
 
 from sage.rings.rational_field import QQ
 from sage.rings.integer_ring import ZZ
@@ -1122,11 +1123,10 @@ def _power_operation(self, n, operation):
 
         iters = [self.support()] * n
         filtration = {}
-        from sage.categories.cartesian_product import cartesian_product
-        for degrees in cartesian_product(iters):
+        for degrees in product(*iters):
             deg = sum(degrees)
             filt_deg = filtration.get(deg, set())
-            for i in cartesian_product([indices.get(d) for d in degrees]):
+            for i in product(*[indices.get(d) for d in degrees]):
                 pow_i = T.index_map(*i)
                 if pow_i is not None:
                     filt_deg.add(pow_i)

src/sage/modules/tensor_operations.py

@@ -60,7 +60,7 @@
 #  the License, or (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
-
+from itertools import product
 from collections import defaultdict
 
 from sage.modules.free_module import FreeModule_ambient_field
@@ -90,12 +90,11 @@ def symmetrized_coordinate_sums(dim, n):
         ((0, 0), (0, 1) + (1, 0), (1, 1))
     """
     from sage.structure.formal_sum import FormalSum
-    from sage.categories.cartesian_product import cartesian_product
 
     coordinates = [list(range(dim)) for i in range(n)]
     table = defaultdict(list)
 
-    for i in cartesian_product(coordinates):
+    for i in product(*coordinates):
         sort_i = tuple(sorted(i))
         table[sort_i].append([1, tuple(i)])
 
@@ -344,11 +343,7 @@ def _init_product_vectors(self, i):
         """
         # Pick out the i[j]-th vector
         rays = [list(self._V[j].vectors()[k]) for j, k in enumerate(i)]
-        v = []
-        # Note: convert to list, as cartesian_product of vectors is unrelated
-        from sage.categories.cartesian_product import cartesian_product
-        for r in cartesian_product(rays):
-            v.append(prod(r))   # build up the tensor product
+        v = [prod(r) for r in product(*rays)]  # build up the tensor product
         v = tuple(v)
         # Use index of pre-existing tensor product vector if there is one
         try:
@@ -415,8 +410,7 @@ def _init_product(self):
             [((0, 0), 0), ((0, 1), 1), ((1, 0), 2), ((1, 1), 3), ((2, 0), 3), ((2, 1), 2)]
         """
         V_list_indices = [list(range(V.n_vectors())) for V in self._V]
-        from sage.categories.cartesian_product import cartesian_product
-        for i in cartesian_product(V_list_indices):
+        for i in product(*V_list_indices):
             self._index_map[tuple(i)] = self._init_product_vectors(i)
         self._symmetrize_indices = False
 
@@ -433,12 +427,11 @@ def _init_symmetric(self):
             sage: sorted(Sym2_R._index_map.items())
             [((0, 0), 0), ((0, 1), 1), ((0, 2), 2), ((1, 1), 3), ((1, 2), 4), ((2, 2), 3)]
         """
-        from sage.categories.cartesian_product import cartesian_product
         V_list_indices = [list(range(V.n_vectors())) for V in self._V]
         Sym = symmetrized_coordinate_sums(self._V[0].dimension(),
                                           len(self._V))
         N = len(V_list_indices)
-        for i in cartesian_product(V_list_indices):
+        for i in product(*V_list_indices):
             if any(i[j - 1] > i[j] for j in range(1, N)):
                 continue
             self._index_map[tuple(i)] = self._init_power_operation_vectors(i, Sym)