Trac #31668: Run TestSuite on polynomial rings

#27364 fixes a bug that `_test_construction` should have found -- except
`TestSuite` is not called at all for any multivariate polynomial rings.

We add a bunch of `TestSuite` calls for the rings constructed as
examples in `polynomial_ring_constructor`.

Many tests are failing; we skip these tests to make this ticket
mergeable. In follow-up tickets, these failures should be fixed.

Related:
- https://groups.google.com/g/sage-devel/c/vGzNJKAQWbs/m/nhm1iIPWAwAJ
- https://groups.google.com/g/sage-devel/c/xiH9d4oBwaI/m/9Q0U1bUlAwAJ

URL: https://trac.sagemath.org/31668
Reported by: mkoeppe
Ticket author(s): Matthias Koeppe
Reviewer(s): Vincent Delecroix, Travis Scrimshaw

Author: Release Manager

build/pkgs/configure/checksums.ini

@@ -1,4 +1,4 @@
 tarball=configure-VERSION.tar.gz
-sha1=c39297a2d58601cfa6baa9045140c3485ee9ffab
-md5=534693f57e442ff0cd9e4cfbc4768ebc
-cksum=82888323
+sha1=db995d44fdbaf1c20e95de3257a54d7e71e01dbb
+md5=aa42a4557361c1049b00a8f9b275a84e
+cksum=1730113298

build/pkgs/configure/package-version.txt

@@ -1 +1 @@
-2c3a4cef8d3ce703174c93a92ed0efcbecdd36ba
+f96de9c84911bea01d729290cf707e3bab988864

src/sage/categories/pushout.py

@@ -833,7 +833,7 @@ class PolynomialFunctor(ConstructionFunctor):
     """
     rank = 9
 
-    def __init__(self, var, multi_variate=False, sparse=False):
+    def __init__(self, var, multi_variate=False, sparse=False, implementation=None):
         """
         TESTS::
 
@@ -857,6 +857,7 @@ def __init__(self, var, multi_variate=False, sparse=False):
         self.var = var
         self.multi_variate = multi_variate
         self.sparse = sparse
+        self.implementation = implementation
 
     def _apply_functor(self, R):
         """
@@ -870,7 +871,10 @@ def _apply_functor(self, R):
 
         """
         from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-        return PolynomialRing(R, self.var, sparse=self.sparse)
+        kwds = {}
+        if self.implementation:
+            kwds['implementation'] = self.implementation
+        return PolynomialRing(R, self.var, sparse=self.sparse, **kwds)
 
     def _apply_functor_to_morphism(self, f):
         """

src/sage/rings/polynomial/multi_polynomial.pyx

@@ -2575,6 +2575,43 @@ cdef class MPolynomial(CommutativeRingElement):
         d = self.dict()
         return all(c.is_nilpotent() for c in d.values())
 
+    def _test_subs(self, tester=None, **options):
+        r"""
+        Run some tests using the ``subs`` method.
+
+        TESTS::
+
+            sage: R.<x,y> = QQbar[]
+            sage: (x + y)._test_subs()
+        """
+        if tester is None:
+            tester = self._tester(**options)
+
+        gens = self.parent().gens()
+
+        if gens:
+            # substituting all variables (in a polynomial ring with variables) with 0
+            d = {str(gen): 0 for gen in gens}
+            tester.assertEqual(self.subs(**d).parent(), self.parent().base_ring())
+
+            # substituting all variables (in a polynomial ring with variables)
+            # with elements of another ring
+            from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+            other = PolynomialRing(self.parent().base_ring(), 'other', len(gens))
+            other_gens = other.gens()
+            d = {str(gen): other_gen for gen, other_gen in zip(gens, other_gens)}
+            tester.assertEqual(self.subs(**d).parent(), other)
+
+        if len(gens) > 1:
+            # substituting one variable (in a polynomial ring with variables) with 0
+            d = {str(gens[0]): 0}
+            tester.assertEqual(self.subs(**d).parent(), self.parent())
+
+            # test error checking: partial substitution by elements
+            # from another ring is not allowed
+            d = {str(gens[0]): other_gens[0]}
+            with tester.assertRaises((ValueError, TypeError)):
+                self.subs(**d)
 
 cdef remove_from_tuple(e, int ind):
     w = list(e)

src/sage/rings/polynomial/multi_polynomial_ring_base.pyx

@@ -1299,6 +1299,27 @@ cdef class MPolynomialRing_base(sage.rings.ring.CommutativeRing):
 
         return self(dict(zip(M, C)))
 
+    def some_elements(self):
+        r"""
+        Return a list of polynomials.
+
+        This is typically used for running generic tests.
+
+        EXAMPLES::
+
+            sage: R.<x,y> = QQ[]
+            sage: R.some_elements()
+            [x, y, x + y, x^2 + x*y, 0, 1]
+
+        """
+        R = self.base_ring()
+        L = list(self.gens())
+        if L:
+            L.append(L[0] + L[-1])
+            L.append(L[0] * L[-1])
+        L.extend([self.zero(), self.one()])
+        return L
+
     def change_ring(self, base_ring=None, names=None, order=None):
         """
         Return a new multivariate polynomial ring which isomorphic to

src/sage/rings/polynomial/pbori/pbori.pyx

@@ -308,7 +308,7 @@ cdef class BooleanPolynomialRing(MPolynomialRing_base):
         True
         sage: x2 > x3
         True
-        sage: TestSuite(P).run()
+        sage: TestSuite(P).run(skip=["_test_zero_divisors", "_test_elements"])
 
     Boolean polynomial rings are unique parent structures. We
     thus have::

src/sage/rings/polynomial/polynomial_ring.py

@@ -619,6 +619,9 @@ def flattening_morphism(self):
             return IdentityMorphism(self)
 
     def construction(self):
+        """
+        Return the construction functor.
+        """
         return categories.pushout.PolynomialFunctor(self.variable_name(), sparse=self.__is_sparse), self.base_ring()
 
     def completion(self, p, prec=20, extras=None):
@@ -1951,6 +1954,38 @@ def _repr_(self):
         s = PolynomialRing_commutative._repr_(self)
         return s + self._implementation_repr
 
+    def construction(self):
+        """
+        Return the construction functor.
+
+        EXAMPLES::
+
+            sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_integral_domain as PRing
+            sage: R = PRing(ZZ, 'x'); R
+            Univariate Polynomial Ring in x over Integer Ring
+            sage: functor, arg = R.construction(); functor, arg
+            (Poly[x], Integer Ring)
+            sage: functor.implementation is None
+            True
+
+            sage: R = PRing(ZZ, 'x', implementation='NTL'); R
+            Univariate Polynomial Ring in x over Integer Ring (using NTL)
+            sage: functor, arg = R.construction(); functor, arg
+            (Poly[x], Integer Ring)
+            sage: functor.implementation
+            'NTL'
+        """
+        implementation = None
+        # NOTE: This is obviously not a complete solution. The parents
+        # don't keep track in a clean way what the implementation is.
+        # Trac #31852 is the task of finding a general solution for
+        # construction functors of parents with multiple
+        # implementations, such as MatrixSpace, Polyhedron, and
+        # PolynomialRing.
+        if 'NTL' in self._implementation_repr:
+            implementation = 'NTL'
+        return categories.pushout.PolynomialFunctor(self.variable_name(), sparse=self.is_sparse(),
+                                                    implementation=implementation), self.base_ring()
 
 class PolynomialRing_field(PolynomialRing_integral_domain,
                            ring.PrincipalIdealDomain):

src/sage/rings/polynomial/polynomial_ring_constructor.py

@@ -418,22 +418,22 @@ def PolynomialRing(base_ring, *args, **kwds):
 
     The generic implementation is different in some cases::
 
-        sage: R = PolynomialRing(GF(2), 'j', implementation="generic"); type(R)
+        sage: R = PolynomialRing(GF(2), 'j', implementation="generic"); TestSuite(R).run(skip=['_test_construction', '_test_pickling']); type(R)
         <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_field_with_category'>
-        sage: S = PolynomialRing(GF(2), 'j'); type(S)
+        sage: S = PolynomialRing(GF(2), 'j'); TestSuite(S).run(); type(S)
         <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_mod_p_with_category'>
 
-        sage: R = PolynomialRing(ZZ, 'x,y', implementation="generic"); type(R)
+        sage: R = PolynomialRing(ZZ, 'x,y', implementation="generic"); TestSuite(R).run(skip=['_test_elements', '_test_elements_eq_transitive']); type(R)
         <class 'sage.rings.polynomial.multi_polynomial_ring.MPolynomialRing_polydict_domain_with_category'>
-        sage: S = PolynomialRing(ZZ, 'x,y'); type(S)
+        sage: S = PolynomialRing(ZZ, 'x,y'); TestSuite(S).run(skip='_test_elements'); type(S)
         <class 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomialRing_libsingular'>
 
     Sparse univariate polynomials only support a generic
     implementation::
 
-        sage: R = PolynomialRing(ZZ, 'j', sparse=True); type(R)
+        sage: R = PolynomialRing(ZZ, 'j', sparse=True); TestSuite(R).run(); type(R)
         <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_integral_domain_with_category'>
-        sage: R = PolynomialRing(GF(49), 'j', sparse=True); type(R)
+        sage: R = PolynomialRing(GF(49), 'j', sparse=True); TestSuite(R).run(); type(R)
         <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_field_with_category'>
 
     If the requested implementation is not known or not supported for
@@ -487,11 +487,14 @@ def PolynomialRing(base_ring, *args, **kwds):
     :trac:`7712` and :trac:`13760` are fixed::
 
         sage: P.<y,z> = PolynomialRing(RealIntervalField(2))
+        sage: TestSuite(P).run(skip=['_test_elements', '_test_elements_eq_transitive'])
         sage: Q.<x> = PolynomialRing(P)
+        sage: TestSuite(Q).run(skip=['_test_additive_associativity', '_test_associativity', '_test_distributivity', '_test_prod'])
         sage: C = (y-x)^3
         sage: C(y/2)
         1.?*y^3
         sage: R.<x,y> = PolynomialRing(RIF,2)
+        sage: TestSuite(R).run(skip=['_test_elements', '_test_elements_eq_transitive'])
         sage: RIF(-2,1)*x
         0.?e1*x
 
@@ -549,6 +552,49 @@ def PolynomialRing(base_ring, *args, **kwds):
         Traceback (most recent call last):
         ...
         TypeError: unable to convert 'x' to an integer
+
+    We run the testsuite for various polynomial rings, skipping tests that currently fail::
+
+        sage: R.<w> = PolynomialRing(PolynomialRing(GF(7),'k')); TestSuite(R).run(); R
+        Univariate Polynomial Ring in w over Univariate Polynomial Ring in k over Finite Field of size 7
+        sage: ZxNTL = PolynomialRing(ZZ, 'x', implementation='NTL'); TestSuite(ZxNTL).run(skip='_test_pickling'); ZxNTL
+        Univariate Polynomial Ring in x over Integer Ring (using NTL)
+        sage: ZxFLINT = PolynomialRing(ZZ, 'x', implementation='FLINT'); TestSuite(ZxFLINT).run(); ZxFLINT
+        Univariate Polynomial Ring in x over Integer Ring
+        sage: Zx = PolynomialRing(ZZ, 'x', implementation='generic'); TestSuite(Zx).run(skip=['_test_construction', '_test_pickling']); Zx
+        Univariate Polynomial Ring in x over Integer Ring
+        sage: R = PolynomialRing(QQ, 'a,b,c'); TestSuite(R).run(skip='_test_elements'); R
+        Multivariate Polynomial Ring in a, b, c over Rational Field
+        sage: R = PolynomialRing(QQ, 'x,y,z', order='degrevlex'); TestSuite(R).run(skip='_test_elements'); R
+        Multivariate Polynomial Ring in x, y, z over Rational Field
+        sage: S = PolynomialRing(QQ, 'x,y,z', order='invlex'); TestSuite(S).run(skip=['_test_construction', '_test_elements']); S
+        Multivariate Polynomial Ring in x, y, z over Rational Field
+        sage: Q0 = PolynomialRing(QQ,[]); TestSuite(Q0).run(skip=['_test_elements', '_test_elements_eq_transitive', '_test_gcd_vs_xgcd', '_test_quo_rem']); Q0
+        Multivariate Polynomial Ring in no variables over Rational Field
+        sage: P.<x> = PolynomialRing(QQ, implementation="singular"); TestSuite(P).run(skip=['_test_construction', '_test_elements', '_test_euclidean_degree', '_test_quo_rem']); P
+        Multivariate Polynomial Ring in x over Rational Field
+        sage: Q1 = PolynomialRing(QQ,"x",1); TestSuite(Q1).run(skip=['_test_construction', '_test_elements', '_test_euclidean_degree', '_test_quo_rem']); Q1
+        Multivariate Polynomial Ring in x over Rational Field
+        sage: Q0 = PolynomialRing(QQ,"x",0); TestSuite(Q0).run(skip=['_test_elements', '_test_elements_eq_transitive', '_test_gcd_vs_xgcd', '_test_quo_rem']); Q0
+        Multivariate Polynomial Ring in no variables over Rational Field
+        sage: R = PolynomialRing(GF(2), 'j', implementation="generic"); TestSuite(R).run(skip=['_test_construction', '_test_pickling']); type(R)
+        <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_field_with_category'>
+        sage: S = PolynomialRing(GF(2), 'j'); TestSuite(S).run(); type(S)
+        <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_mod_p_with_category'>
+        sage: R = PolynomialRing(ZZ, 'x,y', implementation="generic"); TestSuite(R).run(skip=['_test_elements', '_test_elements_eq_transitive']); type(R)
+        <class 'sage.rings.polynomial.multi_polynomial_ring.MPolynomialRing_polydict_domain_with_category'>
+        sage: S = PolynomialRing(ZZ, 'x,y'); TestSuite(S).run(skip='_test_elements'); type(S)
+        <class 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomialRing_libsingular'>
+        sage: R = PolynomialRing(ZZ, 'j', sparse=True); TestSuite(R).run(); type(R)
+        <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_integral_domain_with_category'>
+        sage: R = PolynomialRing(GF(49), 'j', sparse=True); TestSuite(R).run(); type(R)
+        <class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_field_with_category'>
+        sage: P.<y,z> = PolynomialRing(RealIntervalField(2))
+        sage: TestSuite(P).run(skip=['_test_elements', '_test_elements_eq_transitive'])
+        sage: Q.<x> = PolynomialRing(P)
+        sage: TestSuite(Q).run(skip=['_test_additive_associativity', '_test_associativity', '_test_distributivity', '_test_prod'])
+        sage: R.<x,y> = PolynomialRing(RIF,2)
+        sage: TestSuite(R).run(skip=['_test_elements', '_test_elements_eq_transitive'])
     """
     if not ring.is_Ring(base_ring):
         raise TypeError("base_ring {!r} must be a ring".format(base_ring))

src/sage/rings/ring.pyx

@@ -132,8 +132,8 @@ cdef class Ring(ParentWithGens):
         running ._test_some_elements() . . . pass
         running ._test_zero() . . . pass
         running ._test_zero_divisors() . . . pass
-        sage: TestSuite(QQ['x','y']).run()
-        sage: TestSuite(ZZ['x','y']).run()
+        sage: TestSuite(QQ['x','y']).run(skip='_test_elements')
+        sage: TestSuite(ZZ['x','y']).run(skip='_test_elements')
         sage: TestSuite(ZZ['x','y']['t']).run()
 
     Test against another bug fixed in :trac:`9944`::

src/sage/sets/image_set.py

@@ -79,7 +79,7 @@ def __init__(self, map, domain_subset, *, category=None, is_injective=None, inve
             sage: f = H(lambda v: v[0]*x + v[1]*(x^2-y) + v[2]^2*(y+2) + v[3] - v[0]^2)
             sage: Im = f.image()
             sage: TestSuite(Im).run(skip=['_test_an_element', '_test_pickling',
-            ....:                         '_test_some_elements'])
+            ....:                         '_test_some_elements', '_test_elements'])
         """
         if not is_Parent(domain_subset):
             from sage.sets.set import Set