Deprecate is_LaurentSeriesRing, is_MPowerSeriesRing, is_PowerSeriesRing

src/sage/categories/category_types.py

@@ -616,8 +616,8 @@ def __contains__(self, x):
         """
         if super().__contains__(x):
             return True
-        from sage.rings.ideal import is_Ideal
-        return is_Ideal(x) and x.ring() == self.ring()
+        from sage.rings.ideal import Ideal_generic
+        return isinstance(x, Ideal_generic) and x.ring() == self.ring()
 
     def __call__(self, v):
         """

src/sage/combinat/finite_state_machine.py

@@ -10790,8 +10790,8 @@ def entry(transition):
             else:
                 base_ring = transition_matrix.parent().base_ring()
                 from sage.rings.polynomial.multi_polynomial_ring \
-                    import is_MPolynomialRing
-                if is_MPolynomialRing(base_ring):
+                    import MPolynomialRing_base
+                if isinstance(base_ring, MPolynomialRing_base):
                     # if base_ring is already a multivariate polynomial
                     # ring, extend it instead of creating a univariate
                     # polynomial ring over a polynomial ring.  This

src/sage/crypto/lattice.py

@@ -22,7 +22,7 @@
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
-from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
+from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
 
 def gen_lattice(type='modular', n=4, m=8, q=11, seed=None,
                 quotient=None, dual=False, ntl=False, lattice=False):
@@ -254,7 +254,7 @@ def gen_lattice(type='modular', n=4, m=8, q=11, seed=None,
 
         P = quotient.parent()
         # P should be a univariate polynomial ring over ZZ_q
-        if not is_PolynomialRing(P):
+        if not isinstance(P, PolynomialRing_general):
             raise TypeError("quotient should be a univariate polynomial")
         assert P.base_ring() is ZZ_q
 

src/sage/dynamics/arithmetic_dynamics/affine_ds.py

@@ -46,7 +46,7 @@ class initialization directly.
 from sage.rings.finite_rings.finite_field_base import FiniteField
 from sage.rings.fraction_field import FractionField
 from sage.rings.fraction_field import FractionField_generic
-from sage.rings.quotient_ring import is_QuotientRing
+from sage.rings.quotient_ring import QuotientRing_nc
 from sage.schemes.affine.affine_morphism import SchemeMorphism_polynomial_affine_space
 from sage.schemes.affine.affine_morphism import SchemeMorphism_polynomial_affine_space_field
 from sage.schemes.affine.affine_morphism import SchemeMorphism_polynomial_affine_space_finite_field
@@ -268,7 +268,7 @@ def __classcall_private__(cls, morphism_or_polys, domain=None):
             PR = PR.ring().change_ring(K).fraction_field()
             polys = [PR(poly) for poly in polys]
         else:
-            quotient_ring = any(is_QuotientRing(poly.parent()) for poly in polys)
+            quotient_ring = any(isinstance(poly.parent(), QuotientRing_nc) for poly in polys)
             # If any of the list entries lies in a quotient ring, we try
             # to lift all entries to a common polynomial ring.
             if quotient_ring:

src/sage/dynamics/arithmetic_dynamics/projective_ds.py

@@ -94,9 +94,9 @@
 from sage.rings.integer_ring import ZZ
 from sage.rings.polynomial.flatten import FlatteningMorphism, UnflatteningMorphism
 from sage.rings.morphism import RingHomomorphism_im_gens
-from sage.rings.polynomial.multi_polynomial_ring_base import is_MPolynomialRing
+from sage.rings.polynomial.multi_polynomial_ring_base import MPolynomialRing_base
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
+from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
 from sage.rings.quotient_ring import QuotientRing_generic
 from sage.rings.rational_field import QQ
 from sage.rings.real_mpfr import RealField
@@ -384,7 +384,7 @@
             polys = list(morphism_or_polys)
             if len(polys) == 1:
                 raise ValueError("list/tuple must have at least 2 polynomials")
-            test = lambda x: is_PolynomialRing(x) or is_MPolynomialRing(x)
+            test = lambda x: isinstance(x, PolynomialRing_general) or isinstance(x, MPolynomialRing_base)
             if not all(test(poly.parent()) for poly in polys):
                 try:
                     polys = [poly.lift() for poly in polys]
@@ -394,8 +394,8 @@
             # homogenize!
             f = morphism_or_polys
             aff_CR = f.parent()
-            if (not is_PolynomialRing(aff_CR) and not isinstance(aff_CR, FractionField_generic)
-                and not (is_MPolynomialRing(aff_CR) and aff_CR.ngens() == 1)):
+            if (not isinstance(aff_CR, PolynomialRing_general) and not isinstance(aff_CR, FractionField_generic)
+                and not (isinstance(aff_CR, MPolynomialRing_base) and aff_CR.ngens() == 1)):
                 msg = '{} is not a single variable polynomial or rational function'
                 raise ValueError(msg.format(f))
             if isinstance(aff_CR, FractionField_generic):
@@ -3533,7 +3533,7 @@
                         if hyperplane_found:
                             break
                 else:
-                    if is_PolynomialRing(R) or is_MPolynomialRing(R) or isinstance(R, FractionField_generic):
+                    if isinstance(R, PolynomialRing_general) or isinstance(R, MPolynomialRing_base) or isinstance(R, FractionField_generic):
                         # for polynomial rings, we can get an infinite family of hyperplanes
                         # by increasing the degree
                         var = R.gen()
@@ -4598,7 +4598,7 @@
                     for k in ZZ(n).divisors():
                         if ZZ(n/k).is_prime():
                             Sn.append(k)
-                    if (is_PolynomialRing(R) or is_MPolynomialRing(R)):
+                    if (isinstance(R, PolynomialRing_general) or isinstance(R, MPolynomialRing_base)):
                         phi = FlatteningMorphism(CR)
                         flatCR = phi.codomain()
                         Ik = flatCR.ideal(1)
@@ -4881,7 +4881,7 @@
             raise NotImplementedError('periodic points not implemented for fraction function fields; '
                 'clear denominators and use the polynomial ring instead')
         if isinstance(R, FractionField_generic):
-            if is_MPolynomialRing(R.ring()):
+            if isinstance(R.ring(), MPolynomialRing_base):
                 raise NotImplementedError('periodic points not implemented for fraction function fields; '
                     'clear denominators and use the polynomial ring instead')
         CR = f_sub.coordinate_ring()
@@ -4954,7 +4954,7 @@
                         for k in ZZ(n).divisors():
                             if ZZ(n/k).is_prime():
                                 Sn.append(k)
-                        if (is_PolynomialRing(R) or is_MPolynomialRing(R)):
+                        if (isinstance(R, PolynomialRing_general) or isinstance(R, MPolynomialRing_base)):
                             phi = FlatteningMorphism(CR)
                             flatCR = phi.codomain()
                             Ik = flatCR.ideal(1)
@@ -5785,7 +5785,7 @@
                 else:
                     F = base_ring
                     if isinstance(base_ring, FractionField_generic):
-                        if is_MPolynomialRing(base_ring.ring()) or is_PolynomialRing(base_ring.ring()):
+                        if isinstance(base_ring.ring(), MPolynomialRing_base) or isinstance(base_ring.ring(), PolynomialRing_general):
                             f.normalize_coordinates()
                             f_ring = f.change_ring(base_ring.ring())
                             X = f_ring.periodic_points(n, minimal=False, formal=formal, return_scheme=True)
@@ -5888,7 +5888,7 @@
         base_ring = dom.base_ring()
         if isinstance(base_ring, FractionField_generic):
             base_ring = base_ring.ring()
-        if (is_PolynomialRing(base_ring) or is_MPolynomialRing(base_ring)):
+        if (isinstance(base_ring, PolynomialRing_general) or isinstance(base_ring, MPolynomialRing_base)):
             base_ring = base_ring.base_ring()
         elif base_ring in FunctionFields():
             base_ring = base_ring.constant_base_field()
@@ -8473,7 +8473,7 @@
         #we find one and not go all the way to the splitting field
         i = 0
         if G.degree() != 0:
-            if is_MPolynomialRing(G.parent()):
+            if isinstance(G.parent(), MPolynomialRing_base):
                 G = G.polynomial(G.variable(0))
         else:
             #no other fixed points

src/sage/ext/fast_callable.pyx

@@ -475,9 +475,9 @@ def fast_callable(x, domain=None, vars=None,
             x = x.function(*vars)
 
         if vars is None:
-            from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
-            from sage.rings.polynomial.multi_polynomial_ring import is_MPolynomialRing
-            if is_PolynomialRing(x.parent()) or is_MPolynomialRing(x.parent()):
+            from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
+            from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_base
+            if isinstance(x.parent(), PolynomialRing_general) or isinstance(x.parent(), MPolynomialRing_base):
                 vars = x.parent().variable_names()
             else:
                 # constant

src/sage/interfaces/singular.py

@@ -1797,7 +1797,7 @@ def sage_poly(self, R=None, kcache=None):
         # TODO: Refactor imports to move this to the top
         from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_polydict
         from sage.rings.polynomial.multi_polynomial_libsingular import MPolynomialRing_libsingular
-        from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
+        from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
         from sage.rings.polynomial.polydict import ETuple
         from sage.rings.polynomial.polynomial_singular_interface import can_convert_to_singular
         from sage.rings.quotient_ring import QuotientRing_generic
@@ -1888,7 +1888,7 @@ def sage_poly(self, R=None, kcache=None):
 
             return R(sage_repr)
 
-        elif is_PolynomialRing(R) and (ring_is_fine or can_convert_to_singular(R)):
+        elif isinstance(R, PolynomialRing_general) and (ring_is_fine or can_convert_to_singular(R)):
 
             sage_repr = [0] * int(self.deg() + 1)
 

src/sage/matrix/matrix_space.py

@@ -298,15 +298,15 @@ def get_matrix_class(R, nrows, ncols, sparse, implementation):
             except ImportError:
                 pass
             else:
-                if polynomial_ring.is_PolynomialRing(R) and R.base_ring() in _Fields:
+                if isinstance(R, polynomial_ring.PolynomialRing_general) and R.base_ring() in _Fields:
                     try:
                         from . import matrix_polynomial_dense
                     except ImportError:
                         pass
                     else:
                         return matrix_polynomial_dense.Matrix_polynomial_dense
 
-                elif multi_polynomial_ring_base.is_MPolynomialRing(R) and R.base_ring() in _Fields:
+                elif isinstance(R, multi_polynomial_ring_base.MPolynomialRing_base) and R.base_ring() in _Fields:
                     try:
                         from . import matrix_mpolynomial_dense
                     except ImportError:

src/sage/modular/modform/hecke_operator_on_qexp.py

@@ -19,7 +19,7 @@
 from sage.rings.infinity import Infinity
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
-from sage.rings.power_series_ring_element import is_PowerSeries
+from sage.rings.power_series_ring_element import PowerSeries
 
 lazy_import('sage.rings.number_field.number_field', 'CyclotomicField')
 
@@ -87,7 +87,7 @@ def hecke_operator_on_qexp(f, n, k, eps=None,
         # ZZ can coerce to GF(p), but QQ can't.
         eps = DirichletGroup(1, base_ring=ZZ)[0]
     if check:
-        if not (is_PowerSeries(f) or isinstance(f, ModularFormElement)):
+        if not (isinstance(f, PowerSeries) or isinstance(f, ModularFormElement)):
             raise TypeError("f (=%s) must be a power series or modular form" % f)
         if not isinstance(eps, DirichletCharacter):
             raise TypeError("eps (=%s) must be a Dirichlet character" % eps)
@@ -235,7 +235,7 @@ def hecke_operator_on_basis(B, n, k, eps=None, already_echelonized=False):
         eps = DirichletGroup(1, R)[0]
     all_powerseries = True
     for x in B:
-        if not is_PowerSeries(x):
+        if not isinstance(x, PowerSeries):
             all_powerseries = False
     if not all_powerseries:
         raise TypeError("each element of B must be a power series")

src/sage/modular/modform/space.py

@@ -70,7 +70,7 @@
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
 from sage.rings.power_series_ring import PowerSeriesRing
-from sage.rings.power_series_ring_element import is_PowerSeries
+from sage.rings.power_series_ring_element import PowerSeries
 from sage.rings.rational_field import QQ
 from sage.categories.rings import Rings
 
@@ -1121,7 +1121,7 @@ def _element_constructor_(self, x, check=True):
 
             return self(x.q_expansion(self._q_expansion_module().degree()))
 
-        elif is_PowerSeries(x):
+        elif isinstance(x, PowerSeries):
             if x.prec() == PlusInfinity():
                 if x == 0:
                     return self.element_class(self, self.free_module().zero())
@@ -1914,7 +1914,7 @@ def find_in_space(self, f, forms=None, prec=None, indep=True):
                 B = V.span_of_basis(w)
             else:
                 B = V.span(w)
-        if is_PowerSeries(f) and f.prec() < n:
+        if isinstance(f, PowerSeries) and f.prec() < n:
             raise ValueError("you need at least %s terms of precision" % n)
         x = V(f.padded_list(n))
         return B.coordinates(x)

src/sage/modular/modform_hecketriangle/abstract_space.py

@@ -22,15 +22,16 @@
 from sage.rings.infinity import infinity
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
-from sage.rings.laurent_series_ring import is_LaurentSeriesRing
-from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
-from sage.rings.power_series_ring import is_PowerSeriesRing
+from sage.rings.laurent_series_ring import LaurentSeriesRing
+from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
+from sage.rings.power_series_ring import PowerSeriesRing_generic
 from sage.rings.rational_field import QQ
 from sage.structure.element import parent
 
 from .abstract_ring import FormsRing_abstract
 
 lazy_import('sage.rings.imaginary_unit', 'I')
+lazy_import('sage.rings.lazy_series_ring', ('LazyLaurentSeriesRing', 'LazyPowerSeriesRing'))
 lazy_import('sage.rings.qqbar', 'QQbar')
 
 
@@ -257,8 +258,9 @@ def _element_constructor_(self, el):
         # can be changed in construct_form
         # resp. construct_quasi_form))
         P = parent(el)
-        if is_LaurentSeriesRing(P) or is_PowerSeriesRing(P):
-            if (self.is_modular()):
+        if isinstance(P, (LaurentSeriesRing, PowerSeriesRing_generic,
+                          LazyLaurentSeriesRing, LazyPowerSeriesRing)):
+            if self.is_modular():
                 return self.construct_form(el)
             else:
                 return self.construct_quasi_form(el)
@@ -1721,7 +1723,7 @@ def construct_form(self, laurent_series, order_1=ZZ.zero(), check=True, rational
         """
 
         base_ring = laurent_series.base_ring()
-        if is_PolynomialRing(base_ring.base()):
+        if isinstance(base_ring.base(), PolynomialRing_general):
             if not (self.coeff_ring().has_coerce_map_from(base_ring)):
                 raise ValueError("The Laurent coefficients don't coerce into the coefficient ring of self!")
         elif rationalize:
@@ -2015,7 +2017,7 @@ def construct_quasi_form(self, laurent_series, order_1=ZZ.zero(), check=True, ra
         """
 
         base_ring = laurent_series.base_ring()
-        if is_PolynomialRing(base_ring.base()):
+        if isinstance(base_ring.base(), PolynomialRing_general):
             if not (self.coeff_ring().has_coerce_map_from(base_ring)):
                 raise ValueError("The Laurent coefficients don't coerce into the coefficient ring of self!")
         elif rationalize:
@@ -2282,7 +2284,7 @@ def rationalize_series(self, laurent_series, coeff_bound=1e-10, denom_factor=ZZ(
 
         # If the coefficients already coerce to our coefficient ring
         # and are in polynomial form we simply return the Laurent series
-        if (is_PolynomialRing(base_ring.base())):
+        if (isinstance(base_ring.base(), PolynomialRing_general)):
             if (self.coeff_ring().has_coerce_map_from(base_ring)):
                 return laurent_series
             else:

src/sage/modular/modform_hecketriangle/functors.py

@@ -79,15 +79,15 @@ def _get_base_ring(ring, var_name="d"):
     """
 
     # from sage.rings.fraction_field import FractionField_generic
-    from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
+    from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
     from sage.categories.pushout import FractionField as FractionFieldFunctor
 
     base_ring = ring
     # if (isinstance(base_ring, FractionField_generic)):
     #    base_ring = base_ring.base()
     if (base_ring.construction() and base_ring.construction()[0] == FractionFieldFunctor()):
         base_ring = base_ring.construction()[1]
-    if (is_PolynomialRing(base_ring) and base_ring.ngens() == 1 and base_ring.variable_name() == var_name):
+    if (isinstance(base_ring, PolynomialRing_general) and base_ring.ngens() == 1 and base_ring.variable_name() == var_name):
         base_ring = base_ring.base()
     if (base_ring.construction() and base_ring.construction()[0] == FractionFieldFunctor()):
         base_ring = base_ring.construction()[1]