Implement iteration over more polynomial rings

src/sage/categories/category.py

@@ -1692,7 +1692,7 @@ def parent_class(self):
             True
             sage: Algebras(QQ).parent_class is Algebras(ZZ).parent_class
             False
-            sage: Algebras(ZZ['t']).parent_class is Algebras(ZZ['t','x']).parent_class
+            sage: Algebras(ZZ['t']).parent_class is Algebras(ZZ['x']).parent_class
             True
 
         See :class:`CategoryWithParameters` for an abstract base class for
@@ -1742,7 +1742,7 @@ def element_class(self):
             True
             sage: Algebras(QQ).element_class is Algebras(ZZ).element_class
             False
-            sage: Algebras(ZZ['t']).element_class is Algebras(ZZ['t','x']).element_class
+            sage: Algebras(ZZ['t']).element_class is Algebras(ZZ['x']).element_class
             True
 
         These classes are constructed with ``__slots__ = ()``, so

src/sage/categories/modules_with_basis.py

@@ -2608,7 +2608,7 @@ def _an_element_(self):
                     B[()] + B[(1,2)] + 3*B[(1,2,3)] + 2*B[(1,3,2)]
                     sage: ABA = cartesian_product((A, B, A))
                     sage: ABA.an_element()  # indirect doctest
-                    2*B[(0, word: )] + 2*B[(0, word: a)] + 3*B[(0, word: b)]
+                    2*B[(0, word: )] + 2*B[(1, ())] + 3*B[(1, (1,3,2))]
                 """
                 from .cartesian_product import cartesian_product
                 return cartesian_product([module.an_element() for module in self.modules])

src/sage/combinat/root_system/root_lattice_realizations.py

@@ -694,14 +694,14 @@ def positive_roots(self, index_set=None):
                 sage: [PR.unrank(i) for i in range(10)]                                 # needs sage.graphs
                 [alpha[1],
                  alpha[2],
+                 alpha[0] + alpha[1] + alpha[2] + alpha[3],
                  alpha[3],
+                 2*alpha[0] + 2*alpha[1] + 2*alpha[2] + 2*alpha[3],
                  alpha[1] + alpha[2],
+                 3*alpha[0] + 3*alpha[1] + 3*alpha[2] + 3*alpha[3],
                  alpha[2] + alpha[3],
-                 alpha[1] + alpha[2] + alpha[3],
-                 alpha[0] + 2*alpha[1] + alpha[2] + alpha[3],
-                 alpha[0] + alpha[1] + 2*alpha[2] + alpha[3],
-                 alpha[0] + alpha[1] + alpha[2] + 2*alpha[3],
-                 alpha[0] + 2*alpha[1] + 2*alpha[2] + alpha[3]]
+                 4*alpha[0] + 4*alpha[1] + 4*alpha[2] + 4*alpha[3],
+                 alpha[1] + alpha[2] + alpha[3]]
             """
             if self.cartan_type().is_affine():
                 from sage.sets.disjoint_union_enumerated_sets \
@@ -798,18 +798,18 @@ def positive_real_roots(self):
                 sage: [PR.unrank(i) for i in range(5)]                                  # needs sage.graphs
                 [alpha[1],
                  alpha[2],
+                 2*alpha[0] + 2*alpha[1] + alpha[2],
                  alpha[1] + alpha[2],
-                 2*alpha[1] + alpha[2],
-                 alpha[0] + alpha[1] + alpha[2]]
+                 4*alpha[0] + 4*alpha[1] + 2*alpha[2]]
 
                 sage: Q = RootSystem(['D',3,2]).root_lattice()
                 sage: PR = Q.positive_roots()                                           # needs sage.graphs
                 sage: [PR.unrank(i) for i in range(5)]                                  # needs sage.graphs
                 [alpha[1],
                  alpha[2],
+                 alpha[0] + alpha[1] + alpha[2],
                  alpha[1] + 2*alpha[2],
-                 alpha[1] + alpha[2],
-                 alpha[0] + alpha[1] + 2*alpha[2]]
+                 2*alpha[0] + 2*alpha[1] + 2*alpha[2]]
             """
             if self.cartan_type().is_finite():
                 return tuple(RecursivelyEnumeratedSet(self.simple_roots(),

src/sage/rings/polynomial/laurent_polynomial_ring_base.py

@@ -62,8 +62,12 @@ def __init__(self, R):
         self._R = R
         names = R.variable_names()
         self._one_element = self.element_class(self, R.one())
+        category = R.category()
+        if "Enumerated" in category.axioms():
+            # this ring should also be countable, but __iter__ is not yet implemented
+            category = category._without_axiom("Enumerated")
         CommutativeRing.__init__(self, R.base_ring(), names=names,
-                                 category=R.category())
+                                 category=category)
         ernames = []
         for n in names:
             ernames.append(n)

src/sage/rings/polynomial/polynomial_ring.py

@@ -153,6 +153,7 @@
 from sage.rings.ring import Ring, CommutativeRing
 from sage.structure.element import RingElement
 import sage.rings.rational_field as rational_field
+from sage.rings.infinity import Infinity
 from sage.rings.rational_field import QQ
 from sage.rings.integer_ring import ZZ
 from sage.rings.integer import Integer
@@ -263,7 +264,7 @@
               (Dedekind domains and euclidean domains
                and noetherian rings and infinite enumerated sets
                and metric spaces)
-             and Category of infinite sets
+             and Category of infinite enumerated sets
 
             sage: category(GF(7)['x'])
             Join of Category of euclidean domains
@@ -273,7 +274,7 @@
             and Category of commutative algebras over
               (finite enumerated fields and subquotients of monoids
                and quotients of semigroups)
-            and Category of infinite sets
+            and Category of infinite enumerated sets
 
         TESTS:
 
@@ -286,7 +287,7 @@
         Check that category for zero ring::
 
             sage: PolynomialRing(Zmod(1), 'x').category()
-            Category of finite commutative rings
+            Category of finite enumerated commutative rings
 
         Check ``is_finite`` inherited from category (:issue:`24432`)::
 
@@ -305,7 +306,7 @@
         # We trust that, if category is given, it is useful and does not need to be joined
         # with the default category
         if base_ring.is_zero():
-            category = categories.rings.Rings().Commutative().Finite()
+            category = categories.rings.Rings().Commutative().Finite().Enumerated()
         else:
             defaultcat = polynomial_default_category(base_ring.category(), 1)
             category = check_default_category(defaultcat, category)
@@ -1050,6 +1051,83 @@
         h = self._cached_hash = hash((self.base_ring(),self.variable_name()))
         return h
 
+    def __iter__(self):
+        r"""
+        Return iterator over the elements of this polynomial ring.
+
+        EXAMPLES::
+
+            sage: from itertools import islice
+            sage: R.<x> = GF(3)[]
+            sage: list(islice(iter(R), 10))
+            [0, 1, 2, x, x + 1, x + 2, 2*x, 2*x + 1, 2*x + 2, x^2]
+
+        TESTS::
+
+            sage: R.<x> = Integers(1)[]
+            sage: [*R]
+            [0]
+            sage: R.<x> = QQ[]
+            sage: l = list(islice(iter(R), 50)); l
+            [0, 1, -1, x, 1/2, x + 1, x^2, -1/2, -x, x^2 + 1, x^3, 2, x - 1, ...]
+            sage: len(set(l))
+            50
+        """
+        R = self.base_ring()
+        # adapted from sage.modules.free_module.FreeModule_generic.__iter__
+        iters = []
+        v = []
+        n = 0
+        yield self.zero()
+        if R.is_zero():
+            return
+
+        zero = R.zero()
+        if R.cardinality() == Infinity:
+            from sage.categories.sets_cat import cartesian_product
+            from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
+            from sage.sets.family import Family
+            from sage.rings.semirings.non_negative_integer_semiring import NN
+            from sage.sets.set import Set
+            R_nonzero = Set(R) - Set([zero])
+
+            def polynomials_with_degree(d):
+                """
+                Return the family of polynomials with degree exactly ``d``.
+                """
+                nonlocal self, R, R_nonzero
+                return Family(cartesian_product([R] * d + [R_nonzero]),
+                              lambda t: self([*t]), lazy=True)
+
+            yield from DisjointUnionEnumeratedSets(Family(NN, polynomials_with_degree))
+            assert False, "this should not be reached"
+
+        while True:
+            if n == len(iters):
+                iters.append(iter(R))
+                v.append(next(iters[n]))
+                assert v[n] == zero, ("first element of iteration must be zero otherwise result "
+                                      "of this and free module __iter__ will be incorrect")
+            try:
+                v[n] = next(iters[n])
+                yield self(v)
+                n = 0
+            except StopIteration:
+                iters[n] = iter(R)
+                v[n] = next(iters[n])
+                assert v[n] == zero
+                n += 1
+
+    def _an_element_(self):
+        """
+        Return an arbitrary element of this polynomial ring.
+
+        Strictly speaking this is not necessary because it is already provided by the category
+        framework, but before :issue:`39399` this returns the generator, we keep the behavior
+        because it is more convenient.
+        """
+        return self.gen()
+
     def _repr_(self):
         try:
             return self._cached_repr

src/sage/rings/polynomial/polynomial_ring_constructor.py

@@ -898,6 +898,7 @@ def _multi_variate(base_ring, names, sparse=None, order='degrevlex', implementat
 from sage import categories
 from sage.categories.algebras import Algebras
 # Some fixed categories, in order to avoid the function call overhead
+_EnumeratedSets = categories.sets_cat.Sets().Enumerated()
 _FiniteSets = categories.sets_cat.Sets().Finite()
 _InfiniteSets = categories.sets_cat.Sets().Infinite()
 _EuclideanDomains = categories.euclidean_domains.EuclideanDomains()
@@ -944,12 +945,28 @@ def polynomial_default_category(base_ring_category, n_variables):
         True
         sage: QQ['s']['t'].category() is UniqueFactorizationDomains() & CommutativeAlgebras(QQ['s'].category()).WithBasis().Infinite()
         True
+
+    TESTS::
+
+        sage: category(GF(7)['x'])
+        Join of Category of euclidean domains
+         and Category of algebras with basis over
+          (finite enumerated fields and subquotients of monoids
+           and quotients of semigroups)
+        and Category of commutative algebras over
+          (finite enumerated fields and subquotients of monoids
+           and quotients of semigroups)
+        and Category of infinite enumerated sets
     """
     category = Algebras(base_ring_category).WithBasis()
 
     if n_variables:
         # here we assume the base ring to be nonzero
         category = category.Infinite()
+        if base_ring_category.is_subcategory(_EnumeratedSets) and n_variables == 1:
+            # n_variables == 1 is not necessary but iteration over multivariate polynomial ring
+            # is not yet implemented
+            category = category.Enumerated()
     else:
         if base_ring_category.is_subcategory(_Fields):
             category = category & _Fields

src/sage/sets/disjoint_union_enumerated_sets.py

@@ -392,32 +392,130 @@
         """
         TESTS::
 
+            sage: from itertools import islice
             sage: U4 = DisjointUnionEnumeratedSets(
             ....:          Family(NonNegativeIntegers(), Permutations))
-            sage: it = iter(U4)
-            sage: [next(it), next(it), next(it), next(it), next(it), next(it)]
+            sage: list(islice(iter(U4), 6))
             [[], [1], [1, 2], [2, 1], [1, 2, 3], [1, 3, 2]]
 
             sage: # needs sage.combinat
             sage: U4 = DisjointUnionEnumeratedSets(
             ....:          Family(NonNegativeIntegers(), Permutations),
             ....:          keepkey=True, facade=False)
-            sage: it = iter(U4)
-            sage: [next(it), next(it), next(it), next(it), next(it), next(it)]
-            [(0, []), (1, [1]), (2, [1, 2]), (2, [2, 1]), (3, [1, 2, 3]), (3, [1, 3, 2])]
-            sage: el = next(it); el.parent() == U4
-            True
-            sage: el.value == (3, Permutation([2,1,3]))
+            sage: l = list(islice(iter(U4), 7)); l
+            [(0, []), (1, [1]), (2, [1, 2]), (2, [2, 1]), (3, [1, 2, 3]), (3, [1, 3, 2]), (3, [2, 1, 3])]
+            sage: l[-1].parent() is U4
             True
+
+        Check when both the set of keys and each element set is finite::
+
+            sage: list(DisjointUnionEnumeratedSets(
+            ....:          Family({1: FiniteEnumeratedSet([1,2,3]),
+            ....:                  2: FiniteEnumeratedSet([4,5,6])})))
+            [1, 2, 3, 4, 5, 6]
+
+        Check when the set of keys is finite but each element set is infinite::
+
+            sage: list(islice(DisjointUnionEnumeratedSets(
+            ....:                 Family({1: NonNegativeIntegers(),
+            ....:                         2: NonNegativeIntegers()}), keepkey=True), 0, 10))
+            [(1, 0), (1, 1), (2, 0), (1, 2), (2, 1), (1, 3), (2, 2), (1, 4), (2, 3), (1, 5)]
+
+        Check when the set of keys is infinite but each element set is finite::
+
+            sage: list(islice(DisjointUnionEnumeratedSets(
+            ....:                 Family(NonNegativeIntegers(), lambda x: FiniteEnumeratedSet(range(x))),
+            ....:                 keepkey=True), 0, 20))
+            [(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3),
+             (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4)]
+
+        Check when some element sets are empty (note that if there are infinitely many sets
+        but only finitely many elements in total, the iteration will hang)::
+
+            sage: list(DisjointUnionEnumeratedSets(
+            ....:          Family({1: FiniteEnumeratedSet([]),
+            ....:                  2: FiniteEnumeratedSet([]),
+            ....:                  3: FiniteEnumeratedSet([]),
+            ....:                  4: FiniteEnumeratedSet([]),
+            ....:                  5: FiniteEnumeratedSet([1,2,3]),
+            ....:                  6: FiniteEnumeratedSet([4,5,6])})))
+            [1, 2, 3, 4, 5, 6]
+
+        Check when there's one infinite set and infinitely many finite sets::
+
+            sage: list(islice(DisjointUnionEnumeratedSets(
+            ....:                 Family(NonNegativeIntegers(), lambda x: FiniteEnumeratedSet([]) if x else NonNegativeIntegers())),
+            ....:                 0, 10))
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+        The following cannot be determined to be finite, but the first elements can still be retrieved::
+
+            sage: U = DisjointUnionEnumeratedSets(
+            ....:         Family(NonNegativeIntegers(), lambda x: FiniteEnumeratedSet([] if x >= 2 else [1, 2])),
+            ....:         keepkey=True)
+            sage: list(U)  # not tested
+            sage: list(islice(iter(U), 5))  # not tested, hangs
+            sage: list(islice(iter(U), 4))
+            [(0, 1), (0, 2), (1, 1), (1, 2)]
         """
-        for k in self._family.keys():
-            for el in self._family[k]:
+        def wrap_element(el, k):
+            nonlocal self
+            if self._keepkey:
+                el = (k, el)
+            if self._facade:
+                return el
+            else:
+                return self.element_class(self, el)  # Bypass correctness tests
+
+        keys_iter = iter(self._family.keys())
+        if self._keepkey:
+            seen_keys = []
+        el_iters = []
+        while keys_iter is not None or el_iters:
+            if keys_iter is not None:
+                try:
+                    k = next(keys_iter)
+                except StopIteration:
+                    keys_iter = None
+                if keys_iter is not None:
+                    el_set = self._family[k]
+                    try:
+                        is_finite = el_set.is_finite()
+                    except (AttributeError, NotImplementedError):
+                        is_finite = False
+                    if is_finite:
+                        for el in el_set:
+                            yield wrap_element(el, k)
+                    else:
+                        el_iters.append(iter(el_set))
+                        if self._keepkey:
+                            seen_keys.append(k)
+            any_stopped = False
+            for i, obj in enumerate(zip(seen_keys, el_iters) if self._keepkey else el_iters):
+                if self._keepkey:
+                    k, el_iter = obj
+                else:
+                    k = None
+                    el_iter = obj
+                try:
+                    el = next(el_iter)
+                except StopIteration:
+                    el_iters[i] = None
+                    any_stopped = True
+                    continue
+                yield wrap_element(el, k)
+            if any_stopped:
                 if self._keepkey:
-                    el = (k, el)
-                if self._facade:
-                    yield el
+                    filtered = [*zip(
+                        *[(k, el_iter) for k, el_iter in zip(seen_keys, el_iters) if el_iter is not None])]
+                    if filtered:
+                        seen_keys = list(filtered[0])
+                        el_iters = list(filtered[1])
+                    else:
+                        seen_keys = []
+                        el_iters = []
                 else:
-                    yield self.element_class(self, el)  # Bypass correctness tests
+                    el_iters = [el_iter for el_iter in el_iters if el_iter is not None]
 
     def an_element(self):
         """