Trac #32635: sage.matrix.matrix_space: Import element classes on demand, fall back to generic on ImportError

This is to support modularization.

Also, in extension of #32566, we switch another method to use
`sage.rings.abc` for `isinstance` testing.

(cherry-picked from #32432)

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

Author: Release Manager

src/sage/matrix/matrix2.pyx

@@ -10720,10 +10720,8 @@ cdef class Matrix(Matrix1):
             sage: mu*G == A
             True
         """
-        import sage.rings.real_double
-        import sage.rings.complex_double
         R = self.base_ring()
-        if R in [sage.rings.real_double.RDF, sage.rings.complex_double.CDF]:
+        if isinstance(R, (sage.rings.abc.RealDoubleField, sage.rings.abc.ComplexDoubleField)):
             Q, R = self.transpose().QR()
             m = R.nrows(); n = R.ncols()
             if m > n:

src/sage/matrix/matrix_space.py

@@ -40,33 +40,16 @@
 from . import matrix_generic_dense
 from . import matrix_generic_sparse
 
-from . import matrix_modn_sparse
-
-from . import matrix_mod2_dense
-from . import matrix_gf2e_dense
-
-from . import matrix_integer_dense
-from . import matrix_integer_sparse
-
-from . import matrix_rational_dense
-from . import matrix_rational_sparse
-
-from . import matrix_polynomial_dense
-from . import matrix_mpolynomial_dense
-
 # Sage imports
 import sage.structure.coerce
 from sage.structure.parent import Parent
 from sage.structure.unique_representation import UniqueRepresentation
 import sage.rings.integer as integer
-import sage.rings.number_field.all
-import sage.rings.finite_rings.integer_mod_ring
 import sage.rings.finite_rings.finite_field_constructor
-import sage.rings.polynomial.multi_polynomial_ring_base
 import sage.misc.latex as latex
 import sage.modules.free_module
 
-from sage.misc.all import lazy_attribute
+from sage.misc.lazy_attribute import lazy_attribute
 
 from sage.categories.rings import Rings
 from sage.categories.fields import Fields
@@ -209,25 +192,54 @@ def get_matrix_class(R, nrows, ncols, sparse, implementation):
         if implementation is None:
             # Choose default implementation:
             if R is sage.rings.integer_ring.ZZ:
-                return matrix_integer_dense.Matrix_integer_dense
+                try:
+                    from . import matrix_integer_dense
+                except ImportError:
+                    pass
+                else:
+                    return matrix_integer_dense.Matrix_integer_dense
 
-            if R is sage.rings.rational_field.QQ:
-                return matrix_rational_dense.Matrix_rational_dense
+            elif R is sage.rings.rational_field.QQ:
+                try:
+                    from . import matrix_rational_dense
+                except ImportError:
+                    pass
+                else:
+                    return matrix_rational_dense.Matrix_rational_dense
 
-            if R is sage.rings.real_double.RDF:
-                from . import matrix_real_double_dense
-                return matrix_real_double_dense.Matrix_real_double_dense
+            elif isinstance(R, sage.rings.abc.RealDoubleField):
+                try:
+                    from . import matrix_real_double_dense
+                except ImportError:
+                    pass
+                else:
+                    return matrix_real_double_dense.Matrix_real_double_dense
 
-            if R is sage.rings.complex_double.CDF:
+            elif isinstance(R, sage.rings.abc.ComplexDoubleField):
                 if implementation is None or implementation == 'numpy':
-                    from . import matrix_complex_double_dense
-                    return matrix_complex_double_dense.Matrix_complex_double_dense
+                    try:
+                        from . import matrix_complex_double_dense
+                    except ImportError:
+                        pass
+                    else:
+                        return matrix_complex_double_dense.Matrix_complex_double_dense
 
-            if sage.rings.finite_rings.finite_field_constructor.is_FiniteField(R):
+            elif sage.rings.finite_rings.finite_field_constructor.is_FiniteField(R):
                 if R.order() == 2:
-                    return matrix_mod2_dense.Matrix_mod2_dense
+                    try:
+                        from . import matrix_mod2_dense
+                    except ImportError:
+                        pass
+                    else:
+                        return matrix_mod2_dense.Matrix_mod2_dense
+
                 if R.characteristic() == 2 and R.order() <= 65536:  # 65536 == 2^16
-                    return matrix_gf2e_dense.Matrix_gf2e_dense
+                    try:
+                        from . import matrix_gf2e_dense
+                    except ImportError:
+                        pass
+                    else:
+                        return matrix_gf2e_dense.Matrix_gf2e_dense
 
                 if (not R.is_prime_field()) and R.order() < 256:
                     try:
@@ -247,37 +259,67 @@ def get_matrix_class(R, nrows, ncols, sparse, implementation):
                 from . import matrix_cyclo_dense
                 return matrix_cyclo_dense.Matrix_cyclo_dense
 
-            from sage.symbolic.ring import SR
-            if R is SR:
-                from . import matrix_symbolic_dense
-                return matrix_symbolic_dense.Matrix_symbolic_dense
+            try:
+                from sage.symbolic.ring import SR
+            except ImportError:
+                pass
+            else:
+                if R is SR:
+                    try:
+                        from . import matrix_symbolic_dense
+                    except ImportError:
+                        pass
+                    else:
+                        return matrix_symbolic_dense.Matrix_symbolic_dense
 
-            from sage.rings.complex_arb import ComplexBallField
-            if isinstance(R, ComplexBallField):
-                from . import matrix_complex_ball_dense
-                return matrix_complex_ball_dense.Matrix_complex_ball_dense
+            if isinstance(R, sage.rings.abc.ComplexBallField):
+                try:
+                    from . import matrix_complex_ball_dense
+                except ImportError:
+                    pass
+                else:
+                    return matrix_complex_ball_dense.Matrix_complex_ball_dense
 
-            if sage.rings.polynomial.polynomial_ring.is_PolynomialRing(R) and R.base_ring() in _Fields:
-                return matrix_polynomial_dense.Matrix_polynomial_dense
+            try:
+                from sage.rings.polynomial import polynomial_ring, multi_polynomial_ring_base
+            except ImportError:
+                pass
+            else:
+                if polynomial_ring.is_PolynomialRing(R) and R.base_ring() in _Fields:
+                    try:
+                        from . import matrix_polynomial_dense
+                    except ImportError:
+                        pass
+                    else:
+                        return matrix_polynomial_dense.Matrix_polynomial_dense
 
-            if sage.rings.polynomial.multi_polynomial_ring_base.is_MPolynomialRing(R) and R.base_ring() in _Fields:
-                return matrix_mpolynomial_dense.Matrix_mpolynomial_dense
+                elif multi_polynomial_ring_base.is_MPolynomialRing(R) and R.base_ring() in _Fields:
+                    try:
+                        from . import matrix_mpolynomial_dense
+                    except ImportError:
+                        pass
+                    else:
+                        return matrix_mpolynomial_dense.Matrix_mpolynomial_dense
 
             # The fallback
             return matrix_generic_dense.Matrix_generic_dense
 
         # Deal with request for a specific implementation
         if implementation == 'flint':
             if R is sage.rings.integer_ring.ZZ:
+                from . import matrix_integer_dense
                 return matrix_integer_dense.Matrix_integer_dense
             if R is sage.rings.rational_field.QQ:
+                from . import matrix_rational_dense
                 return matrix_rational_dense.Matrix_rational_dense
             raise ValueError("'flint' matrices are only available over the integers or the rationals")
 
         if implementation == 'm4ri':
             if R.is_field() and R.characteristic() == 2 and R.order() <= 65536:
                 if R.order() == 2:
+                    from . import matrix_mod2_dense
                     return matrix_mod2_dense.Matrix_mod2_dense
+                from . import matrix_gf2e_dense
                 return matrix_gf2e_dense.Matrix_gf2e_dense
             raise ValueError("'m4ri' matrices are only available for fields of characteristic 2 and order <= 65536")
 
@@ -326,14 +368,30 @@ def get_matrix_class(R, nrows, ncols, sparse, implementation):
     if implementation is not None:
         raise ValueError("cannot choose an implementation for sparse matrices")
 
-    if isinstance(R, sage.rings.abc.IntegerModRing) and R.order() < matrix_modn_sparse.MAX_MODULUS:
-        return matrix_modn_sparse.Matrix_modn_sparse
+    if isinstance(R, sage.rings.abc.IntegerModRing):
+        try:
+            from . import matrix_modn_sparse
+        except ImportError:
+            pass
+        else:
+            if R.order() < matrix_modn_sparse.MAX_MODULUS:
+                return matrix_modn_sparse.Matrix_modn_sparse
 
     if sage.rings.rational_field.is_RationalField(R):
-        return matrix_rational_sparse.Matrix_rational_sparse
+        try:
+            from . import matrix_rational_sparse
+        except ImportError:
+            pass
+        else:
+            return matrix_rational_sparse.Matrix_rational_sparse
 
     if sage.rings.integer_ring.is_IntegerRing(R):
-        return matrix_integer_sparse.Matrix_integer_sparse
+        try:
+            from . import matrix_integer_sparse
+        except ImportError:
+            pass
+        else:
+            return matrix_integer_sparse.Matrix_integer_sparse
 
     # the fallback
     return matrix_generic_sparse.Matrix_generic_sparse
@@ -2457,8 +2515,8 @@ def test_trivial_matrices_inverse(ring, sparse=True, implementation=None, checkr
 
 
 # Fix unpickling Matrix_modn_dense and Matrix_integer_2x2
-from sage.matrix.matrix_modn_dense_double import Matrix_modn_dense_double
-from sage.matrix.matrix_integer_dense import Matrix_integer_dense
+lazy_import('sage.matrix.matrix_modn_dense_double', 'Matrix_modn_dense_double')
+lazy_import('sage.matrix.matrix_integer_dense', 'Matrix_integer_dense')
 from sage.misc.persist import register_unpickle_override
 def _MatrixSpace_ZZ_2x2():
     from sage.rings.integer_ring import ZZ
@@ -2471,5 +2529,6 @@ def _MatrixSpace_ZZ_2x2():
     'MatrixSpace_ZZ_2x2_class', MatrixSpace)
 register_unpickle_override('sage.matrix.matrix_integer_2x2',
     'MatrixSpace_ZZ_2x2', _MatrixSpace_ZZ_2x2)
+lazy_import('sage.matrix.matrix_gf2e_dense', 'unpickle_matrix_gf2e_dense_v0')
 register_unpickle_override('sage.matrix.matrix_mod2e_dense',
-    'unpickle_matrix_mod2e_dense_v0', matrix_gf2e_dense.unpickle_matrix_gf2e_dense_v0)
+    'unpickle_matrix_mod2e_dense_v0', unpickle_matrix_gf2e_dense_v0)