sage.schemes: Deprecate is_... functions

src/bin/sage-fixdoctests

@@ -300,6 +300,9 @@ def process_block(block, src_in_lines, file_optional_tags, venv_explainer=''):
         got = ['']
     else:
         expected, got = block.split('\nGot:\n')
+        got = re.sub(r'(doctest:warning).*^( *DeprecationWarning:)',
+                     r'\1...\n\2',
+                     got, 1, re.DOTALL | re.MULTILINE)
         got = got.splitlines()      # got can't be the empty string
 
     if args.only_tags:

src/sage/categories/schemes.py

@@ -139,8 +139,8 @@ def _call_(self, x):
                       To:   Rational Field
 
         """
-        from sage.schemes.generic.scheme import is_Scheme
-        if is_Scheme(x):
+        from sage.schemes.generic.scheme import Scheme
+        if isinstance(x, Scheme):
             return x
         from sage.schemes.generic.morphism import is_SchemeMorphism
         if is_SchemeMorphism(x):
@@ -197,9 +197,9 @@ def _repr_object_names(self):
             sage: Schemes(Spec(ZZ)) # indirect doctest
             Category of schemes over Integer Ring
         """
-        from sage.schemes.generic.scheme import is_AffineScheme
+        from sage.schemes.generic.scheme import AffineScheme
         base = self.base()
-        if is_AffineScheme(base):
+        if isinstance(base, AffineScheme):
             base = base.coordinate_ring()
         return f"schemes over {base}"
 
@@ -228,8 +228,8 @@ def __init__(self, base):
             sage: AbelianVarieties(Spec(QQ))
             Category of abelian varieties over Rational Field
         """
-        from sage.schemes.generic.scheme import is_AffineScheme
-        if is_AffineScheme(base):
+        from sage.schemes.generic.scheme import AffineScheme
+        if isinstance(base, AffineScheme):
             base = base.coordinate_ring()
         if base not in Fields():
             raise ValueError('category of abelian varieties is only defined over fields')
@@ -331,8 +331,8 @@ def __init__(self, base):
             sage: Jacobians(Spec(QQ))
             Category of Jacobians over Rational Field
         """
-        from sage.schemes.generic.scheme import is_AffineScheme
-        if is_AffineScheme(base):
+        from sage.schemes.generic.scheme import AffineScheme
+        if isinstance(base, AffineScheme):
             base = base.coordinate_ring()
         if base not in Fields():
             raise ValueError('category of Jacobians is only defined over fields')

src/sage/dynamics/arithmetic_dynamics/affine_ds.py

@@ -50,7 +50,7 @@ class initialization directly.
 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
-from sage.schemes.affine.affine_space import is_AffineSpace
+from sage.schemes.affine.affine_space import AffineSpace_generic
 from sage.schemes.affine.affine_space import AffineSpace
 from sage.schemes.affine.affine_subscheme import AlgebraicScheme_subscheme_affine
 from sage.schemes.generic.morphism import SchemeMorphism_polynomial
@@ -246,7 +246,7 @@ def __classcall_private__(cls, morphism_or_polys, domain=None):
             R = morphism.base_ring()
             polys = list(morphism)
             domain = morphism.domain()
-            if not is_AffineSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
+            if not isinstance(domain, AffineSpace_generic) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
                 raise ValueError('"domain" must be an affine scheme')
             if domain != morphism_or_polys.codomain():
                 raise ValueError('domain and codomain do not agree')
@@ -295,7 +295,7 @@ def __classcall_private__(cls, morphism_or_polys, domain=None):
         R = domain.base_ring()
         if isinstance(R, sage.rings.abc.SymbolicRing):
             raise TypeError("symbolic ring cannot be the base ring")
-        if not is_AffineSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
+        if not isinstance(domain, AffineSpace_generic) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
             raise ValueError('"domain" must be an affine scheme')
 
         if R not in Fields():
@@ -523,8 +523,8 @@ def dynatomic_polynomial(self, period):
             sage: G.dehomogenize(1).dynatomic_polynomial(2)
             (1/4*c + 1/4)*x^2 + (-c - 1/2)*x + c + 1
         """
-        from sage.schemes.affine.affine_space import is_AffineSpace
-        if not is_AffineSpace(self.domain()):
+        from sage.schemes.affine.affine_space import AffineSpace_generic
+        if not isinstance(self.domain(), AffineSpace_generic):
             raise NotImplementedError("not implemented for subschemes")
         if self.domain().dimension_relative() > 1:
             raise TypeError("does not make sense in dimension >1")
@@ -1065,8 +1065,8 @@ def cyclegraph(self):
         """
         V = []
         E = []
-        from sage.schemes.affine.affine_space import is_AffineSpace
-        if is_AffineSpace(self.domain()):
+        from sage.schemes.affine.affine_space import AffineSpace_generic
+        if isinstance(self.domain(), AffineSpace_generic):
             for P in self.domain():
                 V.append(str(P))
                 Q = self(P)

src/sage/dynamics/arithmetic_dynamics/berkovich_ds.py

@@ -34,11 +34,11 @@
 from sage.rings.infinity import Infinity
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
-from sage.schemes.affine.affine_space import is_AffineSpace
+from sage.schemes.affine.affine_space import AffineSpace_generic
 from sage.schemes.berkovich.berkovich_space import (Berkovich_Cp_Affine,
-                                Berkovich_Cp_Projective, is_Berkovich_Cp,
+                                Berkovich_Cp_Projective, Berkovich_Cp,
                                 Berkovich_Element_Cp_Affine)
-from sage.schemes.projective.projective_space import is_ProjectiveSpace
+from sage.schemes.projective.projective_space import ProjectiveSpace_ring
 from sage.structure.element import Element
 
 lazy_import('sage.rings.padics.padic_base_generic', 'pAdicBaseGeneric')
@@ -241,7 +241,7 @@ def __classcall_private__(cls, dynamical_system, domain=None, ideal=None):
                     2*3^7 + 2*3^8 + 2*3^9 + 2*3^10 + 2*3^11 + 2*3^12 + 2*3^13 + 2*3^14 +
                     2*3^15 + 2*3^16 + 2*3^17 + 2*3^18 + 2*3^19 + 2*3^20 + O(3^21))
         """
-        if not (is_Berkovich_Cp(domain) or domain is None):
+        if not (isinstance(domain, Berkovich_Cp) or domain is None):
             raise TypeError('domain must be a Berkovich space over Cp, not %s' % domain)
 
         if isinstance(domain, Berkovich_Cp_Affine):
@@ -269,7 +269,7 @@ def __classcall_private__(cls, dynamical_system, domain=None, ideal=None):
         if not isinstance(morphism_domain.base_ring(), pAdicBaseGeneric):
             if morphism_domain.base_ring() in NumberFields():
                 if domain is None and ideal is not None:
-                    if is_AffineSpace(morphism_domain):
+                    if isinstance(morphism_domain, AffineSpace_generic):
                         domain = Berkovich_Cp_Affine(morphism_domain.base_ring(), ideal)
                     else:
                         domain = Berkovich_Cp_Projective(morphism_domain, ideal)
@@ -281,7 +281,7 @@ def __classcall_private__(cls, dynamical_system, domain=None, ideal=None):
                 raise ValueError('base ring of domain of dynamical_system must be p-adic or a number field '
                     'not %s' % morphism_domain.base_ring())
 
-        if is_AffineSpace(morphism_domain):
+        if isinstance(morphism_domain, AffineSpace_generic):
             return DynamicalSystem_Berkovich_affine(dynamical_system, domain)
 
         return DynamicalSystem_Berkovich_projective(dynamical_system, domain)
@@ -531,7 +531,7 @@ def __classcall_private__(cls, dynamical_system, domain=None):
                 raise TypeError('affine dynamical system passed to projective constructor')
         R = dynamical_system.base_ring()
         morphism_domain = dynamical_system.domain()
-        if not is_ProjectiveSpace(morphism_domain):
+        if not isinstance(morphism_domain, ProjectiveSpace_ring):
             raise TypeError('the domain of dynamical_system must be projective space, not %s' % morphism_domain)
         if morphism_domain.dimension_relative() != 1:
             raise ValueError('domain was not relative dimension 1')
@@ -1015,7 +1015,7 @@ def __classcall_private__(cls, dynamical_system, domain=None):
                 raise TypeError('projective dynamical system passed to affine constructor')
         R = dynamical_system.base_ring()
         morphism_domain = dynamical_system.domain()
-        if not is_AffineSpace(morphism_domain):
+        if not isinstance(morphism_domain, AffineSpace_generic):
             raise TypeError('the domain of dynamical_system must be affine space, not %s' % morphism_domain)
         if morphism_domain.dimension_relative() != 1:
             raise ValueError('domain not relative dimension 1')

src/sage/dynamics/arithmetic_dynamics/generic_ds.py

@@ -34,9 +34,9 @@ class initialization directly.
 from sage.misc.lazy_import import lazy_import
 from sage.rings.finite_rings.finite_field_base import FiniteField
 from sage.rings.rational_field import QQ
-from sage.schemes.affine.affine_space import is_AffineSpace
+from sage.schemes.affine.affine_space import AffineSpace_generic
 from sage.schemes.affine.affine_subscheme import AlgebraicScheme_subscheme_affine
-from sage.schemes.berkovich.berkovich_space import is_Berkovich_Cp
+from sage.schemes.berkovich.berkovich_space import Berkovich_Cp
 from sage.schemes.generic.morphism import SchemeMorphism_polynomial
 
 lazy_import('sage.rings.algebraic_closure_finite_field', 'AlgebraicClosureFiniteField_generic')
@@ -165,10 +165,10 @@ def __classcall_private__(cls, morphism_or_polys, domain=None, names=None):
         if isinstance(morphism_or_polys, SchemeMorphism_polynomial):
             domain = morphism_or_polys.domain()
         if domain is not None:
-            if is_AffineSpace(domain) or isinstance(domain, AlgebraicScheme_subscheme_affine):
+            if isinstance(domain, AffineSpace_generic) or isinstance(domain, AlgebraicScheme_subscheme_affine):
                 from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine
                 return DynamicalSystem_affine(morphism_or_polys, domain)
-            if is_Berkovich_Cp(domain):
+            if isinstance(domain, Berkovich_Cp):
                 from sage.dynamics.arithmetic_dynamics.berkovich_ds import DynamicalSystem_Berkovich
                 return DynamicalSystem_Berkovich(morphism_or_polys,domain)
 

src/sage/dynamics/arithmetic_dynamics/product_projective_ds.py

@@ -327,8 +327,8 @@ def cyclegraph(self):
         """
         V = []
         E = []
-        from sage.schemes.product_projective.space import is_ProductProjectiveSpaces
-        if is_ProductProjectiveSpaces(self.domain()):
+        from sage.schemes.product_projective.space import ProductProjectiveSpaces_ring
+        if isinstance(self.domain(), ProductProjectiveSpaces_ring):
             for P in self.domain():
                 V.append(str(P))
                 Q = self(P)

src/sage/dynamics/arithmetic_dynamics/projective_ds.py

@@ -103,12 +103,12 @@ class initialization directly.
 from sage.rings.rational_field import QQ
 from sage.rings.real_mpfr import RealField
 from sage.schemes.generic.morphism import SchemeMorphism_polynomial
-from sage.schemes.product_projective.space import is_ProductProjectiveSpaces
+from sage.schemes.product_projective.space import ProductProjectiveSpaces_ring
 from sage.schemes.projective.projective_morphism import (
     SchemeMorphism_polynomial_projective_space,
     SchemeMorphism_polynomial_projective_space_field,
     SchemeMorphism_polynomial_projective_space_finite_field)
-from sage.schemes.projective.projective_space import ProjectiveSpace, is_ProjectiveSpace
+from sage.schemes.projective.projective_space import ProjectiveSpace, ProjectiveSpace_ring
 from sage.schemes.projective.projective_subscheme import AlgebraicScheme_subscheme_projective
 from sage.structure.element import get_coercion_model
 
@@ -374,7 +374,7 @@ def __classcall_private__(cls, morphism_or_polys, domain=None, names=None):
             polys = list(morphism_or_polys)
             if domain != morphism_or_polys.codomain():
                 raise ValueError('domain and codomain do not agree')
-            if not is_ProjectiveSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_projective):
+            if not isinstance(domain, ProjectiveSpace_ring) and not isinstance(domain, AlgebraicScheme_subscheme_projective):
                 raise ValueError('"domain" must be a projective scheme')
             if R not in Fields():
                 return typecall(cls, polys, domain)
@@ -430,7 +430,7 @@ def __classcall_private__(cls, morphism_or_polys, domain=None, names=None):
         if isinstance(R, sage.rings.abc.SymbolicRing):
             raise TypeError("the base ring cannot be the Symbolic Ring or a symbolic subring")
 
-        if is_ProductProjectiveSpaces(domain):
+        if isinstance(domain, ProductProjectiveSpaces_ring):
             splitpolys = domain._factors(polys)
             for split_poly in splitpolys:
                 split_d = domain._degree(split_poly[0])
@@ -451,7 +451,7 @@ def __classcall_private__(cls, morphism_or_polys, domain=None, names=None):
             msg = 'polys (={}) must be of the same degree'
             raise ValueError(msg.format(polys))
 
-        if not is_ProjectiveSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_projective):
+        if not isinstance(domain, ProjectiveSpace_ring) and not isinstance(domain, AlgebraicScheme_subscheme_projective):
             raise ValueError('"domain" must be a projective scheme')
         if R not in Fields():
             return typecall(cls, polys, domain)
@@ -1264,7 +1264,7 @@ def arakelov_zhang_pairing(self, g, **kwds):
         if n <= 0:
             raise ValueError("Period must be a positive integer.")
 
-        if not (is_ProjectiveSpace(f_domain) and is_ProjectiveSpace(g_domain)):
+        if not (isinstance(f_domain, ProjectiveSpace_ring) and isinstance(g_domain, ProjectiveSpace_ring)):
             raise NotImplementedError("Not implemented for subschemes.")
 
         if f_domain.dimension_relative() > 1:
@@ -1804,7 +1804,7 @@ def primes_of_bad_reduction(self, check=True):
             sage: f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
             [5, 37, 2239, 304432717]
         """
-        if (not is_ProjectiveSpace(self.domain())) or (not is_ProjectiveSpace(self.codomain())):
+        if (not isinstance(self.domain(), ProjectiveSpace_ring)) or (not isinstance(self.codomain(), ProjectiveSpace_ring)):
             raise NotImplementedError("not implemented for subschemes")
         K = FractionField(self.codomain().base_ring())
         #The primes of bad reduction are the support of the resultant for number fields
@@ -3771,7 +3771,7 @@ def critical_subscheme(self):
             TypeError: the function is not a morphism
         """
         PS = self.domain()
-        if not is_ProjectiveSpace(PS):
+        if not isinstance(PS, ProjectiveSpace_ring):
             raise NotImplementedError("not implemented for subschemes")
         if not self.is_morphism():
             raise TypeError("the function is not a morphism")
@@ -4080,7 +4080,7 @@ def is_dynamical_belyi_map(self):
             False
         """
         P = self.codomain()
-        if not is_ProjectiveSpace(P):
+        if not isinstance(P, ProjectiveSpace_ring):
             raise NotImplementedError('only implemented for dynamical systems on projective space')
         if P.dimension_relative() != 1:
             raise NotImplementedError('only implemented for maps on projective space of dimension 1')
@@ -5238,7 +5238,7 @@ def multiplier_spectra(self, n, formal=False, type='point', use_algebraic_closur
 
         if (n < 1):
             raise ValueError("period must be a positive integer")
-        if not is_ProjectiveSpace(PS):
+        if not isinstance(PS, ProjectiveSpace_ring):
             raise NotImplementedError("not implemented for subschemes")
 
         if PS.dimension_relative() > 1:
@@ -5746,7 +5746,7 @@ def sigma_invariants(self, n, formal=False, embedding=None, type='point',
         if n < 1:
             raise ValueError("period must be a positive integer")
         dom = self.domain()
-        if not is_ProjectiveSpace(dom):
+        if not isinstance(dom, ProjectiveSpace_ring):
             raise NotImplementedError("not implemented for subschemes")
         if self.degree() <= 1:
             raise TypeError("must have degree at least 2")
@@ -6397,7 +6397,7 @@ def _is_preperiodic(self, P, err=0.1, return_period=False):
             True
         """
         codomain = self.codomain()
-        if not is_ProjectiveSpace(codomain):
+        if not isinstance(codomain, ProjectiveSpace_ring):
             # in order to calculate the canonical height, we need
             # this map to be a morphism of projective space
             ambient_space = codomain.ambient_space()
@@ -6516,7 +6516,7 @@ def postcritical_set(self, check=True):
             sage: g.postcritical_set()
             [(1 : 0), (0 : 1), (a + 2 : 1)]
         """
-        if not is_ProjectiveSpace(self.domain()):
+        if not isinstance(self.domain(), ProjectiveSpace_ring):
             raise ValueError('must be a dynamical system on projective space')
         if self.domain().dimension_relative() != 1:
             raise ValueError('must be defined on projective space of dimension 1')
@@ -9106,7 +9106,7 @@ def cyclegraph(self):
         """
         V = []
         E = []
-        if is_ProjectiveSpace(self.domain()):
+        if isinstance(self.domain(), ProjectiveSpace_ring):
             for P in self.domain():
                 V.append(P)
                 try:

src/sage/dynamics/arithmetic_dynamics/projective_ds_helper.pyx

@@ -82,8 +82,8 @@ cpdef _fast_possible_periods(self, return_points=False):
         raise TypeError("must be prime field")
 
     PS = self.domain()
-    from sage.schemes.projective.projective_space import is_ProjectiveSpace
-    if not is_ProjectiveSpace(PS) or PS != self.codomain():
+    from sage.schemes.projective.projective_space import ProjectiveSpace_ring
+    if not isinstance(PS, ProjectiveSpace_ring) or PS != self.codomain():
         raise NotImplementedError("must be an endomorphism of projective space")
 
     p = PS.base_ring().order()

src/sage/schemes/affine/affine_homset.py

@@ -261,10 +261,10 @@ def points(self, **kwds):
             may be computed partially or incorrectly.
             [(0.0, 0.0)]
         """
-        from sage.schemes.affine.affine_space import is_AffineSpace
+        from sage.schemes.affine.affine_space import AffineSpace_generic
 
         X = self.codomain()
-        if not is_AffineSpace(X) and X.base_ring() in Fields():
+        if not isinstance(X, AffineSpace_generic) and X.base_ring() in Fields():
             if hasattr(X.base_ring(), 'precision'):
                 numerical = True
                 verbose("Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.", level=0)
@@ -436,7 +436,7 @@ def numerical_points(self, F=None, **kwds):
             ...
             ValueError: tolerance must be positive
         """
-        from sage.schemes.affine.affine_space import is_AffineSpace
+        from sage.schemes.affine.affine_space import AffineSpace_generic
         if F is None:
             F = CC
         if F not in Fields() or not hasattr(F, 'precision'):
@@ -446,7 +446,7 @@ def numerical_points(self, F=None, **kwds):
             raise TypeError('base ring must be a number field')
 
         AA = X.ambient_space().change_ring(F)
-        if not is_AffineSpace(X) and X.base_ring() in Fields():
+        if not isinstance(X, AffineSpace_generic) and X.base_ring() in Fields():
             # Then X must be a subscheme
             dim_ideal = X.defining_ideal().dimension()
             if dim_ideal != 0:  # no points