gh-37232: Still less use of isinstance of old-parents
    
this is removing many calls to isinstance of old-style parent-like
classes

one should use instead the corresponding containment in categories

the case of `Finitefield` is kept for another time

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
    
URL: #37232
Reported by: Frédéric Chapoton
Reviewer(s): Martin Rubey, Matthias Köppe

Author: Release Manager

src/sage/algebras/algebra.py

@@ -18,9 +18,9 @@
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
-from sage.rings.ring import Algebra
 from sage.categories.algebras import Algebras
 
+
 def is_Algebra(x):
     r"""
     Return True if x is an Algebra.
@@ -37,7 +37,4 @@ def is_Algebra(x):
     """
     from sage.misc.superseded import deprecation
     deprecation(35253, "the function is_Algebra is deprecated; use '... in Algebras(base_ring)' instead")
-    try:
-        return isinstance(x, Algebra) or x in Algebras(x.base_ring())
-    except Exception:
-        return False
+    return x in Algebras(x.base_ring())

src/sage/algebras/all.py

@@ -1,8 +1,7 @@
 """
 Algebras
 """
-
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2005 William Stein <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -14,10 +13,13 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 from sage.misc.lazy_import import lazy_import
 
+# old-style class for associative algebras, use Parent instead
+from sage.rings.ring import Algebra
+
 import sage.algebras.catalog as algebras
 
 from .quatalg.all import *
@@ -28,11 +30,9 @@
 from .lie_conformal_algebras.all import *
 
 # Algebra base classes
-from .algebra import Algebra
 from .free_algebra import FreeAlgebra
 from .free_algebra_quotient import FreeAlgebraQuotient
 
-
 from .finite_dimensional_algebras.all import FiniteDimensionalAlgebra
 
 lazy_import('sage.algebras.group_algebra', 'GroupAlgebra')

src/sage/categories/algebras.py

@@ -73,10 +73,7 @@ def __contains__(self, x):
             sage: QQ['x'] in Algebras(CDF)                                              # needs sage.rings.complex_double
             False
         """
-        if super().__contains__(x):
-            return True
-        from sage.rings.ring import Algebra
-        return isinstance(x, Algebra) and x.base_ring() == self.base_ring()
+        return super().__contains__(x)
 
     # def extra_super_categories(self):
     #     """

src/sage/matrix/matrix0.pyx

@@ -39,9 +39,9 @@ from sage.misc.misc_c cimport normalize_index
 
 from sage.categories.fields import Fields
 from sage.categories.integral_domains import IntegralDomains
+from sage.categories.commutative_rings import CommutativeRings
+from sage.categories.rings import Rings
 
-from sage.rings.ring cimport CommutativeRing
-from sage.rings.ring import is_Ring
 import sage.rings.abc
 from sage.rings.integer_ring import is_IntegerRing
 
@@ -1660,7 +1660,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [---]
             [2 4]
         """
-        if not is_Ring(ring):
+        if ring not in Rings():
             raise TypeError("ring must be a ring")
 
         if ring is self._base_ring:
@@ -5323,7 +5323,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [     -x*y*x*y x*y*x + x*y^2 x*y*x - x*y^2]
         """
         # derived classes over a commutative base *just* overload _lmul_ (!!)
-        if isinstance(self._base_ring, CommutativeRing):
+        if self._base_ring in CommutativeRings():
             return self._lmul_(left)
         cdef Py_ssize_t r,c
         x = self._base_ring(left)

src/sage/modular/abvar/homology.py

@@ -52,11 +52,11 @@
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
+from sage.categories.commutative_rings import CommutativeRings
 from sage.modular.hecke.module import HeckeModule_free_module
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
-from sage.rings.ring import CommutativeRing
 from sage.structure.richcmp import richcmp_method, richcmp, richcmp_not_equal
 
 # TODO: we will probably also need homology that is *not* a Hecke module.
@@ -74,11 +74,9 @@ def hecke_polynomial(self, n, var='x'):
 
         INPUT:
 
+        -  ``n`` -- positive integer
 
-        -  ``n`` - positive integer
-
-        -  ``var`` - string (default: 'x') the variable name
-
+        -  ``var`` -- string (default: 'x') the variable name
 
         OUTPUT: a polynomial over ZZ in the given variable
 
@@ -117,7 +115,7 @@ def __init__(self, abvar, base):
             sage: loads(dumps(H)) == H
             True
         """
-        if not isinstance(base, CommutativeRing):
+        if base not in CommutativeRings():
             raise TypeError("base ring must be a commutative ring")
         HeckeModule_free_module.__init__(
             self, base, abvar.level(), weight=2)

src/sage/modular/hecke/module.py

@@ -22,7 +22,7 @@
 from sage.modules.module import Module
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
-from sage.rings.ring import CommutativeRing
+from sage.categories.commutative_rings import CommutativeRings
 from sage.structure.sequence import Sequence
 
 from . import algebra
@@ -76,7 +76,7 @@ def __init__(self, base_ring, level, category=None):
             sage: ModularForms(3, 3).category()
             Category of Hecke modules over Rational Field
         """
-        if not isinstance(base_ring, CommutativeRing):
+        if base_ring not in CommutativeRings():
             raise TypeError("base_ring must be commutative ring")
 
         from sage.categories.hecke_modules import HeckeModules

src/sage/modular/modform/constructor.py

@@ -37,7 +37,7 @@
 import sage.modular.dirichlet as dirichlet
 from sage.rings.integer import Integer
 from sage.rings.rational_field import Q as QQ
-from sage.rings.ring import CommutativeRing
+from sage.categories.commutative_rings import CommutativeRings
 
 from .ambient_eps import ModularFormsAmbient_eps
 from .ambient_g0 import ModularFormsAmbient_g0_Q
@@ -122,11 +122,11 @@ def canonical_parameters(group, level, weight, base_ring):
         except TypeError:
             raise TypeError("group of unknown type.")
         level = Integer(level)
-        if ( m != level ):
+        if m != level:
             raise ValueError("group and level do not match.")
         group = arithgroup.Gamma0(m)
 
-    if not isinstance(base_ring, CommutativeRing):
+    if base_ring not in CommutativeRings():
         raise TypeError("base_ring (=%s) must be a commutative ring" % base_ring)
 
     # it is *very* important to include the level as part of the data

src/sage/modular/modsym/modsym.py

@@ -106,10 +106,11 @@
 
 import weakref
 
+from sage.categories.commutative_rings import CommutativeRings
+from sage.categories.fields import Fields
 import sage.modular.arithgroup.all as arithgroup
 import sage.modular.dirichlet as dirichlet
 from sage.rings.integer import Integer
-from sage.rings.ring import CommutativeRing
 from sage.rings.rational_field import RationalField
 
 
@@ -153,10 +154,10 @@ def canonical_parameters(group, weight, sign, base_ring):
     if base_ring is None:
         base_ring = RationalField()
 
-    if not isinstance(base_ring, CommutativeRing):
+    elif base_ring not in CommutativeRings():
         raise TypeError(f"base_ring (={base_ring}) must be a commutative ring")
 
-    if not base_ring.is_field():
+    elif base_ring not in Fields():
         raise TypeError(f"(currently) base_ring (={base_ring}) must be a field")
 
     return group, weight, sign, base_ring

src/sage/modular/quatalg/brandt.py

@@ -203,6 +203,7 @@
 # ****************************************************************************
 
 from sage.arith.misc import gcd, factor, prime_divisors, kronecker, next_prime
+from sage.categories.commutative_rings import CommutativeRings
 from sage.matrix.constructor import matrix
 from sage.matrix.matrix_space import MatrixSpace
 from sage.misc.cachefunc import cached_method
@@ -219,7 +220,6 @@
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 from sage.rings.power_series_ring import PowerSeriesRing
 from sage.rings.rational_field import QQ
-from sage.rings.ring import CommutativeRing
 from sage.structure.richcmp import richcmp, richcmp_method
 
 lazy_import('sage.algebras.quatalg.quaternion_algebra', ['QuaternionAlgebra', 'basis_for_quaternion_lattice'])
@@ -300,7 +300,7 @@ def BrandtModule(N, M=1, weight=2, base_ring=QQ, use_cache=True):
         raise ValueError("M must be coprime to N")
     if weight < 2:
         raise ValueError("weight must be at least 2")
-    if not isinstance(base_ring, CommutativeRing):
+    if base_ring not in CommutativeRings():
         raise TypeError("base_ring must be a commutative ring")
     key = (N, M, weight, base_ring)
     if use_cache:

src/sage/rings/commutative_algebra.py

@@ -17,7 +17,8 @@
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
-from sage.rings.ring import CommutativeAlgebra
+from sage.categories.commutative_algebras import CommutativeAlgebras
+
 
 def is_CommutativeAlgebra(x):
     """
@@ -35,4 +36,4 @@ def is_CommutativeAlgebra(x):
     """
     from sage.misc.superseded import deprecation
     deprecation(35253, "the function is_CommutativeAlgebra is deprecated; use '... in Algebras(base_ring).Commutative()' instead")
-    return isinstance(x, CommutativeAlgebra)
+    return x in CommutativeAlgebras(x.base_ring())