passagemath-modules 10.5.46__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/matrix/matrix2.pyx

@@ -1545,13 +1545,11 @@ cdef class Matrix(Matrix1):
         m = self._nrows
         n = self._ncols
         if not m <= n:
-            raise ValueError("must have m <= n, but m (=%s) and n (=%s)"%(m, n))
+            raise ValueError(f"must have m <= n, but m (={m}) and n (={n})")
 
         for r from 1 <= r < m+1:
             lst = _choose(n, r)
-            tmp = []
-            for cols in lst:
-                tmp.append(self.prod_of_row_sums(cols))
+            tmp = [self.prod_of_row_sums(cols) for cols in lst]
             s = sum(tmp)
             # sn = (-1)^(m-r)
             if (m - r) % 2 == 0:
@@ -1889,7 +1887,7 @@ cdef class Matrix(Matrix1):
 
         The number of derangements of length `n` is the permanent
         of a matrix with 0 on the diagonal and 1 elsewhere;
-        for `n=21` it is `18795307255050944540` (see :oeis:`A000166`):
+        for `n=21` it is `18795307255050944540` (see :oeis:`A000166`)::
 
            sage: A = identity_matrix(21)
            sage: A.rook_vector(complement=True)[-1]
@@ -3291,6 +3289,16 @@ cdef class Matrix(Matrix1):
             sage: A._charpoly_df()
             x^3 + 8*x^2 + 10*x + 1
 
+        .. NOTE::
+
+            The key feature of this implementation is that it is division-free.
+            This means that it can be used as a generic implementation for any
+            ring (commutative and with multiplicative identity).  The algorithm
+            is described in full detail as Algorithm 3.1 in [Sei2002]_.
+
+            Note that there is a missing minus sign in front of the last term in
+            the penultimate line of Algorithm 3.1.
+
         TESTS::
 
             sage: A = matrix(ZZ, 0, 0)
@@ -3309,15 +3317,11 @@ cdef class Matrix(Matrix1):
             sage: matrix(4, 4, lambda i, j: R.an_element())._charpoly_df()              # needs sage.combinat
             B[1]*x^4 - 4*B[u]*x^3
 
-        .. NOTE::
+        Test that the function is interruptible::
 
-            The key feature of this implementation is that it is division-free.
-            This means that it can be used as a generic implementation for any
-            ring (commutative and with multiplicative identity).  The algorithm
-            is described in full detail as Algorithm 3.1 in [Sei2002]_.
-
-            Note that there is a missing minus sign in front of the last term in
-            the penultimate line of Algorithm 3.1.
+            sage: m = matrix.random(RR, 128)
+            sage: from sage.doctest.util import ensure_interruptible_after
+            sage: with ensure_interruptible_after(1): m.charpoly()
         """
 
         # Validate assertions
@@ -3374,6 +3378,7 @@ cdef class Matrix(Matrix1):
                     for j in range(t+1):
                         s = s + M.get_unsafe(i, j) * a.get_unsafe(p-1, j)
                     a.set_unsafe(p, i, s)
+                    sig_check()
 
                 # Set A[p, t] to be the (t)th entry in a[p, t]
                 A[p] = a.get_unsafe(p, t)
@@ -3480,10 +3485,17 @@ cdef class Matrix(Matrix1):
             raise TypeError("lcm function not defined for elements of the base ring")
         return d
 
-    def diagonal(self):
+    def diagonal(self, offset=0):
         r"""
         Return the diagonal entries of ``self``.
 
+        INPUT:
+
+        - ``offset`` -- integer (default: ``0``); parameter pointing diagonal
+          parallel to the main diagonal. The main diagonal is the one with
+          offset 0. The diagonals above have positive offsets and the diagonals
+          below have negative offsets.
+
         OUTPUT:
 
         A list containing the entries of the matrix that
@@ -3506,6 +3518,16 @@ cdef class Matrix(Matrix1):
             [14 15 16 17 18 19 20]
             sage: B.diagonal()
             [0, 8, 16]
+            sage: B.diagonal(1)
+            [1, 9, 17]
+            sage: B.diagonal(-1)
+            [7, 15]
+            sage: B.diagonal(-2)
+            [14]
+            sage: B.diagonal(100)           # when idx out of range
+            []
+            sage: B.diagonal(-100)
+            []
 
             sage: C = matrix(3, 2, range(6)); C
             [0 1]
@@ -3513,6 +3535,10 @@ cdef class Matrix(Matrix1):
             [4 5]
             sage: C.diagonal()
             [0, 3]
+            sage: C.diagonal(-1)
+            [2, 5]
+            sage: C.diagonal(1)
+            [1]
 
         Empty matrices behave properly. ::
 
@@ -3521,8 +3547,11 @@ cdef class Matrix(Matrix1):
             sage: E.diagonal()
             []
         """
-        n = min(self.nrows(), self.ncols())
-        return [self[i, i] for i in range(n)]
+        if offset >= 0:
+            n = min(self.nrows(), self.ncols() - offset)
+            return [self[i, i + offset] for i in range(n)]
+        n = min(self.nrows() + offset, self.ncols())
+        return [self[i - offset, i] for i in range(n)]
 
     def trace(self):
         """
@@ -3579,6 +3608,42 @@ cdef class Matrix(Matrix1):
                 s += self.get_unsafe(i, j) * other.get_unsafe(j, i)
         return s
 
+    def get_bandwidth(self):
+        """
+        Return the bandwidth of ``self``, which is the maximum `i` such that
+        the `i` superdiagonal or subdiagonal contains a nonzero entry.
+
+        EXAMPLES::
+
+            sage: A = matrix([[1,0,0],[0,1,0],[0,0,1]]); A
+            [1 0 0]
+            [0 1 0]
+            [0 0 1]
+            sage: A.get_bandwidth()
+            0
+
+            sage: B = matrix([[1,2,3],[0,4,5],[0,0,6]]); B
+            [1 2 3]
+            [0 4 5]
+            [0 0 6]
+            sage: B.get_bandwidth()
+            2
+
+            sage: C = matrix(3, 2, range(6)); C
+            [0 1]
+            [2 3]
+            [4 5]
+            sage: C.get_bandwidth()
+            2
+        """
+        cdef Py_ssize_t i
+        diag_range = max(self.nrows(), self.ncols()) - 1
+
+        for i in range(diag_range, 0, -1):
+            if any(self.diagonal(i)) or any(self.diagonal(-i)):
+                return ZZ(i)
+        return ZZ.zero()
+
     #####################################################################################
     # Generic Hessenberg Form and charpoly algorithm
     #####################################################################################
@@ -3615,7 +3680,7 @@ cdef class Matrix(Matrix1):
                 H = self.change_ring(K)
                 H.hessenbergize()
             except TypeError as msg:
-                raise TypeError("%s\nHessenberg form only possible for matrices over a field"%msg)
+                raise TypeError("%s\nHessenberg form only possible for matrices over a field" % msg)
         else:
             H = self.__copy__()
             H.hessenbergize()
@@ -4596,6 +4661,7 @@ cdef class Matrix(Matrix1):
         The "usual" quaternions are a non-commutative ring and computations
         of kernels over these rings are not implemented. ::
 
+            sage: # needs sage.libs.singular
             sage: Q.<i,j,k> = QuaternionAlgebra(-1,-1)
             sage: A = matrix(Q, 2, [i,j,-1,k])
             sage: A.right_kernel_matrix()
@@ -5046,6 +5112,7 @@ cdef class Matrix(Matrix1):
         Matrices over non-commutative rings are not a good idea either.
         These are the "usual" quaternions.  ::
 
+            sage: # needs sage.libs.singular
             sage: Q.<i,j,k> = QuaternionAlgebra(-1,-1)
             sage: A = matrix(Q, 2, [i,j,-1,k])
             sage: A.right_kernel()
@@ -5690,7 +5757,7 @@ cdef class Matrix(Matrix1):
                 return X, Y
             return X
         else:
-            raise ValueError("no algorithm '%s'"%algorithm)
+            raise ValueError("no algorithm '%s'" % algorithm)
 
     def _decomposition_spin_generic(self, is_diagonalizable=False):
         r"""
@@ -5753,14 +5820,16 @@ cdef class Matrix(Matrix1):
                 v = h.list()
 
                 while len(S) < tries:
-                    t = verbose('%s-spinning %s-th random vector'%(num_iterates, len(S)), level=2, caller_name='generic spin decomp')
+                    t = verbose('%s-spinning %s-th random vector' % (num_iterates, len(S)),
+                                level=2, caller_name='generic spin decomp')
                     S.append(self.iterates(V.random_element(), num_iterates))
-                    verbose('done spinning', level=2, t=t, caller_name='generic spin decomp')
+                    verbose('done spinning',
+                            level=2, t=t, caller_name='generic spin decomp')
 
                 for j in range(0 if W is None else W.nrows() // g.degree(), len(S)):
                     # Compute one element of the kernel of g(A)**m.
-                    t = verbose('compute element of kernel of g(A), for g of degree %s'%g.degree(), level=2,
-                                caller_name='generic spin decomp')
+                    t = verbose('compute element of kernel of g(A), for g of degree %s' % g.degree(),
+                                level=2, caller_name='generic spin decomp')
                     w = S[j].linear_combination_of_rows(h.list())
                     t = verbose('done computing element of kernel of g(A)', t=t, level=2, caller_name='generic spin decomp')
 
@@ -5779,7 +5848,7 @@ cdef class Matrix(Matrix1):
                     verbose('computed row space', level=2, t=t, caller_name='generic spin decomp')
                     break
                 else:
-                    verbose('we have not yet generated all the kernel (rank so far=%s, target rank=%s)'%(
+                    verbose('we have not yet generated all the kernel (rank so far=%s, target rank=%s)' % (
                         W.rank(), m*g.degree()), level=2, caller_name='generic spin decomp')
                     tries += 1
                     if tries > 1000*m:  # avoid an insanely long infinite loop
@@ -5815,12 +5884,13 @@ cdef class Matrix(Matrix1):
                 return decomp_seq([(V, m==1)])
         F.sort()
         for g, m in f.factor():
-            t = verbose('decomposition -- Computing g(self) for an irreducible factor g of degree %s'%g.degree(), level=2)
+            t = verbose('decomposition -- Computing g(self) for an irreducible factor g of degree %s' % g.degree(), level=2)
             if is_diagonalizable:
                 B = g(self)
             else:
                 B = g(self)
-                t2 = verbose('decomposition -- raising g(self) to the power %s'%m, level=2)
+                t2 = verbose('decomposition -- raising g(self) to the power %s' % m,
+                             level=2)
                 B = B ** m
                 verbose('done powering', level=2, t=t2)
             t = verbose('decomposition -- done computing g(self)', level=2, t=t)
@@ -5911,7 +5981,7 @@ cdef class Matrix(Matrix1):
         if not self.is_square():
             raise ArithmeticError("self must be a square matrix")
         if M.base_ring() != self.base_ring():
-            raise ArithmeticError("base rings must be the same, but self is over %s and module is over %s"%(
+            raise ArithmeticError("base rings must be the same, but self is over %s and module is over %s" % (
                 self.base_ring(), M.base_ring()))
         if M.degree() != self.ncols():
             raise ArithmeticError("M must be a subspace of an %s-dimensional space" % self.ncols())
@@ -5928,7 +5998,7 @@ cdef class Matrix(Matrix1):
         sum_dim = sum([A.dimension() for A, _ in D])
         assert sum_dim == M.dimension(), \
                "bug in decomposition; " + \
-               "the sum of the dimensions (=%s) of the factors must equal the dimension (%s) of the acted on space:\nFactors found: %s\nSpace: %s"%(sum_dim, M.dimension(), D, M)
+               "the sum of the dimensions (=%s) of the factors must equal the dimension (%s) of the acted on space:\nFactors found: %s\nSpace: %s" % (sum_dim, M.dimension(), D, M)
 
         # 3. Lift decomposition to subspaces of ambient vector space.
         # Each basis vector for an element of D defines a linear
@@ -6475,12 +6545,22 @@ cdef class Matrix(Matrix1):
         matrices with symbolic entries.  ::
 
             sage: A = matrix(QQ, 3, 3, range(9))
-            sage: A.change_ring(RR).eigenspaces_left()
-            Traceback (most recent call last):
-            ...
-            NotImplementedError: eigenspaces cannot be computed reliably
-            for inexact rings such as Real Field with 53 bits of precision,
+            sage: A.change_ring(RR).eigenspaces_left()                                  # needs sage.rings.number_field
+            doctest:warning...
+            UserWarning: eigenspaces cannot be computed reliably for inexact rings such as Real Field with 53 bits of precision,
             consult numerical or symbolic matrix classes for other options
+            [(13.3484692283495,
+              Vector space of degree 3 and dimension 0 over Real Field with 53 bits of precision
+              User basis matrix:
+              []),
+             (-0.000000000000000,
+              Vector space of degree 3 and dimension 1 over Real Field with 53 bits of precision
+              User basis matrix:
+              [ 1.00000000000000 -2.00000000000000  1.00000000000000]),
+             (-1.34846922834953,
+              Vector space of degree 3 and dimension 0 over Real Field with 53 bits of precision
+              User basis matrix:
+              [])]
 
             sage: # needs scipy
             sage: em = A.change_ring(RDF).eigenmatrix_left()
@@ -6556,9 +6636,10 @@ cdef class Matrix(Matrix1):
             msg = 'matrix must be square, not {0} x {1}'
             raise TypeError(msg.format(self.nrows(), self.ncols()))
         if not self.base_ring().is_exact():
+            from warnings import warn
             msg = ("eigenspaces cannot be computed reliably for inexact rings such as {0},\n",
                    "consult numerical or symbolic matrix classes for other options")
-            raise NotImplementedError(''.join(msg).format(self.base_ring()))
+            warn(''.join(msg).format(self.base_ring()))
 
         format = self._eigenspace_format(format)
 
@@ -6830,13 +6911,21 @@ cdef class Matrix(Matrix1):
 
     right_eigenspaces = eigenspaces_right
 
-    def eigenvalues(self, extend=True):
+    def eigenvalues(self, extend=True, algorithm=None) -> Sequence:
         r"""
         Return a sequence of the eigenvalues of a matrix, with
         multiplicity. If the eigenvalues are roots of polynomials in ``QQ``,
         then ``QQbar`` elements are returned that represent each separate
         root.
 
+        INPUT:
+
+        - ``extend`` -- (default: ``True``); see below
+        - ``algorithm`` -- (default: ``None``); algorithm to use,
+          supported values are ``'sage'``, ``'flint'``, ``'mpmath'``, ``'pari'``
+          (passed to :meth:`eigenvectors_left`), or ``'pari_charpoly'``; if ``None``,
+          the algorithm is chosen automatically
+
         If the option ``extend`` is set to ``False``, only eigenvalues in the base
         ring are considered.
 
@@ -6927,6 +7016,96 @@ cdef class Matrix(Matrix1):
                From: Finite Field in z3 of size 3^3
                To:   Algebraic closure of Finite Field of size 3
                Defn: z3 |--> z3)
+
+        TESTS::
+
+            sage: import warnings
+            sage: warnings.simplefilter("always")
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+
+        Test different algorithms::
+
+            sage: m.eigenvalues(algorithm="sage")                                       # needs sage.libs.pari
+            doctest:warning...
+            UserWarning: Using generic algorithm for an inexact ring,
+            which will probably give incorrect results due to numerical precision issues.
+            [-1.41421356237310*I, 1.41421356237310*I]
+            sage: m.eigenvalues(algorithm="flint")                                      # needs sage.libs.flint
+            doctest:warning...
+            FutureWarning: This class/method/function is marked as experimental.
+            It, its functionality or its interface might change without a formal deprecation.
+            See https://github.com/sagemath/sage/issues/30393 for details.
+            [-1.41421356237309*I, 1.41421356237310*I]
+            sage: m.eigenvalues(algorithm="mpmath")  # abs tol 1e-14
+            [-1.41421356237309*I, 1.41421356237309*I]
+            sage: m.eigenvalues(algorithm="pari")  # abs tol 1e-14                      # needs sage.libs.pari
+            [-1.4142135623730950487637880730318329370*I,
+             1.4142135623730950487637880730318329370*I]
+            sage: m.eigenvalues(algorithm="pari_charpoly")  # abs tol 1e-14             # needs sage.libs.pari
+            [-1.41421356237309505*I, 1.41421356237309505*I]
+            sage: m.eigenvalues()
+            [-1.41421356237309505*I, 1.41421356237309505*I]
+            sage: type(m.eigenvalues())
+            <class 'sage.structure.sequence.Sequence_generic'>
+        """
+        if algorithm is None:
+            from sage.rings.abc import RealField, ComplexField
+            R = self.base_ring()
+            if isinstance(R, (RealField, ComplexField)):
+                algorithm = "pari_charpoly"
+            else:
+                algorithm = "sage"
+        if algorithm == "sage":
+            return self._eigenvalues_sage(extend=extend)
+        elif algorithm == "pari_charpoly":
+            from sage.libs.pari import pari
+            return Sequence(pari(self).charpoly().polroots().sage())
+        else:
+            return self._eigenvectors_result_to_eigenvalues(
+                    self._eigenvectors_left(
+                        extend=extend, algorithm=algorithm,
+                        suppress_future_warning=False))
+
+    def _eigenvectors_result_to_eigenvalues(self, eigenvectors: list) -> Sequence:
+        """
+        Convert the result of :meth:`eigenvectors_left` to a sequence of eigenvalues
+        suitable to be returned by :meth:`eigenvalues`.
+
+        INPUT:
+
+        - ``eigenvectors`` -- a list of tuples of the form ``(e,V,n)``
+          as returned by :meth:`eigenvectors_left`
+
+        OUTPUT: a :class:`Sequence` of eigenvalues
+
+        TESTS::
+
+            sage: # needs sage.rings.number_field
+            sage: A = matrix(QQ, [[1, 2], [3, 4]])
+            sage: l = A.eigenvectors_left(); l
+            [(-0.3722813232690144?, [(1, -0.4574271077563382?)], 1),
+             (5.372281323269015?, [(1, 1.457427107756339?)], 1)]
+            sage: A._eigenvectors_result_to_eigenvalues(l)
+            [-0.3722813232690144?, 5.372281323269015?]
+        """
+        return Sequence([e for e, _, _ in eigenvectors])
+
+    def _eigenvalues_sage(self, extend=True) -> Sequence:
+        """
+        Compute the eigenvalues of a matrix using algorithm implemented in Sage.
+
+        INPUT:
+
+        - ``extend`` -- boolean (default: ``True``)
+
+        TESTS::
+
+            sage: # needs sage.rings.number_field
+            sage: A = matrix(QQ, [[1, 2], [3, 4]])
+            sage: A.eigenvalues(algorithm="sage")  # indirect doctest
+            [-0.3722813232690144?, 5.372281323269015?]
+            sage: A._eigenvalues_sage()
+            [-0.3722813232690144?, 5.372281323269015?]
         """
         x = self.fetch('eigenvalues')
         if x is not None:
@@ -6966,7 +7145,7 @@ cdef class Matrix(Matrix1):
         self.cache('eigenvalues', eigenvalues)
         return eigenvalues
 
-    def eigenvectors_left(self, other=None, *, extend=True):
+    def eigenvectors_left(self, other=None, *, extend=True, algorithm=None) -> list:
         r"""
         Compute the left eigenvectors of a matrix.
 
@@ -6979,14 +7158,25 @@ cdef class Matrix(Matrix1):
 
         - ``extend`` -- boolean (default: ``True``)
 
+        - ``algorithm`` -- string (default: ``None``); if ``None``, then it is
+          chosen automatically; options are:
+
+          * ``'sage'``
+          * ``'flint'``
+          * ``'mpmath'``
+          * ``'pari'``
+          * ``'scipy'`` - only supported for matrices over :class:`RDF <sage.rings.real_double.RealDoubleField_class>`
+            and :class:`CDF <sage.rings.complex_double.ComplexDoubleField_class>`
+
         OUTPUT:
 
-        For each distinct eigenvalue, returns a list of the form (e,V,n)
-        where e is the eigenvalue, V is a list of eigenvectors forming a
-        basis for the corresponding left eigenspace, and n is the algebraic
+        Returns a list of tuples of the form ``(e,V,n)``,
+        each tuple corresponds to a distinct eigenvalue,
+        where ``e`` is the eigenvalue, ``V`` is a list of eigenvectors forming a
+        basis for the corresponding left eigenspace, and ``n`` is the algebraic
         multiplicity of the eigenvalue.
 
-        If the option extend is set to False, then only the eigenvalues that
+        If the option ``extend`` is set to ``False``, then only the eigenvalues that
         live in the base ring are considered.
 
         EXAMPLES:
@@ -7042,6 +7232,22 @@ cdef class Matrix(Matrix1):
             sage: K.<i> = QuadraticField(-1)
             sage: m = matrix(K, 4, [2,4*i,-i,0, -4*i,2,-1,0, 2*i,-2,0,0, 4*i+4, 4*i-4,1-i,-2])
             sage: assert all(m*v == e*v for e, vs, _ in m.eigenvectors_right() for v in vs)
+
+        The following currently uses ``algorithm="flint"`` under the hood,
+        but ``FutureWarning`` must not be raised. This is because the internal
+        implementation may change in the future to keep the external interface.
+
+        ::
+
+            sage: # needs sage.libs.flint
+            sage: import warnings
+            sage: warnings.simplefilter("always")
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: m.eigenvectors_left()
+            [(-1.41421356237309*I, [(-0.816496580927726, -0.577350269189626*I)], 1),
+             (1.41421356237310*I, [(-0.866025403784438*I, -0.612372435695794)], 1)]
+            sage: m.eigenvectors_left(extend=False)
+            []
         """
         if other is not None:
             if isinstance(other, bool):
@@ -7057,15 +7263,77 @@ cdef class Matrix(Matrix1):
                                           'for RDF and CDF, but not for %s'
                                           % self.base_ring())
 
-        x = self.fetch('eigenvectors_left')
-        if x is not None:
-            return x
+        if algorithm is None:
+            R = self.base_ring()
+            from sage.rings.abc import RealField, ComplexField
+            if isinstance(R, (RealField, ComplexField)):
+                return self._eigenvectors_left(
+                        other, extend=extend, algorithm='flint', suppress_future_warning=True)
+            else:
+                algorithm = 'sage'
+        return self._eigenvectors_left(
+                other, extend=extend, algorithm=algorithm, suppress_future_warning=False)
+
+    def _eigenvectors_left(self, other=None, *, extend: bool, algorithm: str,
+                           suppress_future_warning: bool) -> list:
+        """
+        Do the same thing as :meth:`eigenvectors_left`, but ``algorithm``
+        cannot be ``None``, and ``suppress_future_warning`` is provided
+        to suppress the ``FutureWarning`` raised by the flint method.
 
+        TESTS::
+
+            sage: # needs sage.libs.flint
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: m._eigenvectors_left(extend=False, algorithm="flint", suppress_future_warning=True)
+            []
+        """
+        if algorithm == 'sage':
+            return self._eigenvectors_left_sage(extend=extend)
+        elif algorithm == 'flint':
+            return self._fix_eigenvectors_extend(self._eigenvectors_left_flint(suppress_future_warning), extend)
+        elif algorithm == 'mpmath':
+            return self._fix_eigenvectors_extend(self._eigenvectors_left_mpmath(), extend)
+        elif algorithm == 'pari':
+            return self._fix_eigenvectors_extend(self._eigenvectors_left_pari(), extend)
+        else:
+            raise ValueError('algorithm value not recognized')
+
+    def _eigenvectors_left_sage(self, *, extend=True) -> list:
+        """
+        Compute the left eigenvectors of a matrix
+        using a generic algorithm implemented in Sage.
+
+        INPUT:
+
+        - ``extend`` -- boolean (default: ``True``)
+
+        OUTPUT:
+
+        See :meth:`eigenvectors_left`.
+
+        TESTS::
+
+            sage: # needs sage.rings.number_field
+            sage: import warnings
+            sage: warnings.simplefilter("always")
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: m.eigenvectors_left(algorithm="sage")
+            doctest:warning...
+            UserWarning: eigenspaces cannot be computed reliably for inexact rings such as Real Field with 53 bits of precision,
+            consult numerical or symbolic matrix classes for other options
+            [(-1.41421356237310*I, [(1.00000000000000, 0.707106781186548*I)], 1),
+             (1.41421356237310*I, [(1.00000000000000, -0.707106781186548*I)], 1)]
+            sage: m.eigenvectors_left(algorithm="sage", extend=False)
+            doctest:warning...
+            UserWarning: eigenspaces cannot be computed reliably for inexact rings such as Real Field with 53 bits of precision,
+            consult numerical or symbolic matrix classes for other options
+            []
+        """
         if not self.base_ring().is_exact():
             from warnings import warn
             warn("Using generic algorithm for an inexact ring, which may result in garbage from numerical precision issues.")
 
-        from sage.categories.homset import hom
         eigenspaces = self.eigenspaces_left(format='galois', algebraic_multiplicity=True)
         evec_list = []
         n = self._nrows
@@ -7079,20 +7347,169 @@ cdef class Matrix(Matrix1):
                 if eigval.parent().fraction_field() == F:
                     evec_eval_list.append((eigval, eigbasis, eigmult))
                 else:
-                    try:
-                        from sage.rings.qqbar import QQbar
-                        eigval_conj = eigval.galois_conjugates(QQbar)
-                    except AttributeError:
-                        raise NotImplementedError("eigenvectors are not implemented for matrices with eigenvalues that are not in the fraction field of the base ring or in QQbar")
+                    from sage.categories.homset import Hom
+                    from sage.rings.abc import RealField
+                    if isinstance(self.base_ring(), RealField):
+                        # then eigval is an element of RR[x]/f(x)
+                        # find all morphism of that ring into CC
+                        f = eigval.parent().modulus()
+                        rs = f.roots(self.base_ring().complex_field(), multiplicities=False)
+                        g = eigval.lift()
+                        eigval_conj = [g(r) for r in rs]
+                    else:
+                        try:
+                            from sage.rings.qqbar import QQbar
+                            eigval_conj = eigval.galois_conjugates(QQbar)
+                        except AttributeError:
+                            raise NotImplementedError("eigenvectors are not implemented for matrices with eigenvalues that are not in the fraction field of the base ring or in QQbar")
 
                     for e in eigval_conj:
-                        m = hom(eigval.parent(), e.parent(), e)
+                        m = Hom(eigval.parent(), e.parent())(e, check=False)
+                        # check=False because the base_ring may not be exact
                         space = (e.parent())**n
                         evec_list = [(space)([m(i) for i in v]) for v in eigbasis]
                         evec_eval_list.append((e, evec_list, eigmult))
 
         return evec_eval_list
 
+    def _fix_eigenvectors_extend(self, eigenvectors: list, extend: bool) -> list:
+        """
+        Fix the eigenvectors if the extend option is set to ``False``.
+
+        INPUT:
+
+        - ``eigenvectors`` -- a list of tuples of the form ``(e,V,n)``
+          as returned by :meth:`eigenvectors_left`
+        - ``extend`` -- boolean
+
+        OUTPUT:
+
+        If ``extend`` is ``True``, return ``eigenvectors`` unchanged.
+        Otherwise, return a new list with only the eigenvalues that live in the base ring.
+
+        TESTS::
+
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: l = m.eigenvectors_left(algorithm="pari"); l  # abs tol 1e-14  # needs sage.libs.pari
+            [(-1.4142135623730950487637880730318329370*I,
+              [(0.707106781186547524*I, 1.00000000000000000)],
+              1),
+             (1.4142135623730950487637880730318329370*I,
+              [(-0.707106781186547524*I, 1.00000000000000000)],
+              1)]
+            sage: m._fix_eigenvectors_extend(l, extend=True)  # abs tol 1e-14    # needs sage.libs.pari
+            [(-1.4142135623730950487637880730318329370*I,
+              [(0.707106781186547524*I, 1.00000000000000000)],
+              1),
+             (1.4142135623730950487637880730318329370*I,
+              [(-0.707106781186547524*I, 1.00000000000000000)],
+              1)]
+            sage: m._fix_eigenvectors_extend(l, extend=False)                    # needs sage.libs.pari
+            []
+        """
+        if extend:
+            return eigenvectors
+        R = self.base_ring()
+        try:
+            if R.algebraic_closure() is R:
+                return eigenvectors
+        except (AttributeError, NotImplementedError):
+            pass
+        return [(e, V, n) for e, V, n in eigenvectors if e in R]
+
+    def _eigenvectors_left_flint(self, suppress_future_warning: bool) -> list:
+        """
+        Compute the left eigenvectors of a matrix
+        using the FLINT library.
+
+        Only works for matrices over ``RealField`` or ``ComplexField``.
+
+        INPUT:
+
+        - ``suppress_future_warning`` -- boolean; whether to suppress
+          the ``FutureWarning``
+
+        OUTPUT:
+
+        See :meth:`eigenvectors_left`.
+
+        TESTS:
+
+        This method is supposed to raise a ``FutureWarning`` but
+        the implementation in :class:`sage.misc.superseded.experimental`
+        only raises the warning at most once, because of doctest ordering
+        the warning is not seen below. See :issue:`39811`. ::
+
+            sage: # needs sage.libs.flint
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: m.eigenvectors_left(algorithm="flint")  # indirect doctest
+            [(-1.41421356237309*I, [(-0.816496580927726, -0.577350269189626*I)], 1),
+             (1.41421356237310*I, [(-0.866025403784438*I, -0.612372435695794)], 1)]
+            sage: m.eigenvectors_left(algorithm="flint", extend=False)
+            []
+        """
+        if suppress_future_warning:
+            import warnings
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", category=FutureWarning)
+                result = self._eigenvectors_left_flint(False)
+            return result
+        from sage.rings.complex_arb import ComplexBallField
+        from sage.rings.complex_mpfr import ComplexField
+        C = ComplexField(self.base_ring().precision())
+        return [(C(e), [v.change_ring(C) for v in V], n) for e, V, n in
+                self.change_ring(ComplexBallField(self.base_ring().precision())).eigenvectors_left()]
+
+    def _eigenvectors_left_mpmath(self) -> list:
+        """
+        Compute the left eigenvectors of a matrix
+        using ``mpmath``.
+
+        Only works for matrices over ``RealField`` or ``ComplexField``.
+
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: m.eigenvectors_left(algorithm="mpmath")
+            [(-1.41421356237309*I, [(-0.866025403784439, -0.612372435695794*I)], 1),
+             (1.41421356237309*I, [(-0.816496580927726*I, -0.577350269189626)], 1)]
+            sage: m.eigenvectors_left(algorithm="mpmath", extend=False)
+            []
+        """
+        from mpmath import mp
+        eigenvalues, eigenvectors = mp.eig(self._mpmath_(), left=True, right=False)
+        from sage.rings.complex_mpfr import ComplexField
+        C = ComplexField(self.base_ring().precision())
+        from sage.modules.free_module_element import vector
+        return [
+                (C(e), [vector(C, V)], 1)
+                for e, V in zip(eigenvalues, eigenvectors.tolist())
+                ]
+
+    def _eigenvectors_left_pari(self) -> list:
+        """
+        Compute the left eigenvectors of a matrix
+        using the PARI library.
+
+        Only works for matrices over ``RealField`` or ``ComplexField``.
+
+            sage: # needs sage.libs.pari
+            sage: m = matrix(RR, [[0, 1], [-2, 0]])
+            sage: m.eigenvectors_left(algorithm="pari")  # abs tol 1e-14
+            [(-1.4142135623730950487637880730318329370*I,
+              [(0.707106781186547524*I, 1.00000000000000000)],
+              1),
+             (1.4142135623730950487637880730318329370*I,
+              [(-0.707106781186547524*I, 1.00000000000000000)],
+              1)]
+            sage: m.eigenvectors_left(algorithm="pari", extend=False)
+            []
+        """
+        from sage.libs.pari import pari
+        eigenvalues, eigenvectors = pari(self).mateigen(flag=1, precision=self.base_ring().precision()).sage()
+        return [
+                (e, [V], 1)
+                for e, V in zip(eigenvalues, eigenvectors.columns())
+                ]
+
     left_eigenvectors = eigenvectors_left
 
     def eigenvectors_right(self, other=None, *, extend=True):
@@ -7780,7 +8197,7 @@ cdef class Matrix(Matrix1):
             try:
                 a, d, p = self._echelon_form_PID()
             except TypeError as msg:
-                raise NotImplementedError("%s\nechelon form over %s not yet implemented"%(msg, self.base_ring()))
+                raise NotImplementedError("%s\nechelon form over %s not yet implemented" % (msg, self.base_ring()))
 
             for c from 0 <= c < self.ncols():
                 for r from 0 <= r < self.nrows():
@@ -7984,7 +8401,7 @@ cdef class Matrix(Matrix1):
                     kwds['algorithm'] = algorithm
                 return self._echelonize_ring(**kwds)
         except ArithmeticError as msg:
-            raise NotImplementedError("%s\nEchelon form not implemented over '%s'."%(msg, basring))
+            raise NotImplementedError("%s\nEchelon form not implemented over '%s'." % (msg, basring))
 
     def echelon_form(self, algorithm='default', cutoff=0, **kwds):
         r"""
@@ -8970,7 +9387,8 @@ cdef class Matrix(Matrix1):
             [ 0  0  0  0]
             [ 0  0  0  0]
         """
-        tm = verbose('strassen echelon of %s x %s matrix'%(self._nrows, self._ncols), level=2)
+        tm = verbose('strassen echelon of %s x %s matrix' % (self._nrows, self._ncols),
+                     level=2)
 
         self.check_mutability()
 
@@ -9248,7 +9666,7 @@ cdef class Matrix(Matrix1):
         """
         if self._subdivisions is None:
             self._subdivisions = ([0, self._nrows], [0, self._ncols])
-        key = "subdivision %s %s"%(i, j)
+        key = "subdivision %s %s" % (i, j)
         sd = self.fetch(key)
         if sd is None:
             sd = self[self._subdivisions[0][i]:self._subdivisions[0][i+1],
@@ -9296,10 +9714,10 @@ cdef class Matrix(Matrix1):
             if not i and not j:
                 return self[x, y]
             else:
-                raise IndexError("No such submatrix %s, %s"%(i, j))
+                raise IndexError("No such submatrix %s, %s" % (i, j))
         if x >= self._subdivisions[0][i+1]-self._subdivisions[0][i] or \
            y >= self._subdivisions[1][j+1]-self._subdivisions[1][j]:
-            raise IndexError("Submatrix %s,%s has no entry %s,%s"%(i, j, x, y))
+            raise IndexError("Submatrix %s,%s has no entry %s,%s" % (i, j, x, y))
         return self[self._subdivisions[0][i] + x, self._subdivisions[1][j] + y]
 
     def _subdivide_on_augment(self, left, right):
@@ -10246,7 +10664,7 @@ cdef class Matrix(Matrix1):
             sage: a.density()
             0
         """
-        cdef int x, y, k
+        cdef Py_ssize_t x, y, k
         k = 0
         nr = self.nrows()
         nc = self.ncols()
@@ -10478,7 +10896,7 @@ cdef class Matrix(Matrix1):
             raise ValueError("self must be a square matrix")
 
         A = self.charpoly().shift(-1)(self)
-        return A if n%2 else -A
+        return A if n % 2 else -A
 
     def QR(self, full=True):
         r"""
@@ -12955,7 +13373,188 @@ cdef class Matrix(Matrix1):
         else:
             return subspace
 
-    def cholesky(self):
+    def _cholesky_extended_ff(self):
+        r"""
+        Performs the extended Cholesky decomposition of a Hermitian matrix over a finite field of square order.
+
+        INPUT:
+
+        - ``self`` -- a square matrix with entries from a finite field of square order
+
+        .. SEEALSO::
+
+            :meth:`cholesky()`
+
+        OUTPUT:
+
+        For a Hermitian matrix `A` the routine returns a matrix `B` such that,
+
+        .. MATH::
+
+            A = B B^*,
+
+        where `B^*` is the conjugate-transpose.
+
+        ALGORITHM:
+
+        First, we ensure the matrix is square and defined over a finite field of square order. Then we can perform the conjugate-symmetric
+        version of Gaussian elimination, but the resulting decomposition matrix `L` might not be lower triangular.
+
+        This is a translation of ``BaseChangeToCanonical`` from the GAP ``forms`` package (for a Hermitian form).
+
+        EXAMPLES:
+
+        Here we use the extended decomposition, where the result may not be a lower triangular matrix::
+
+            sage: # needs sage.rings.finite_rings
+            sage: U = matrix(GF(17**2),[[0,1],[1,0]])
+            sage: B = U._cholesky_extended_ff(); B
+            [13*z2 + 6 3*z2 + 16]
+            [13*z2 + 6 14*z2 + 1]
+            sage: U == B * B.H
+            True
+            sage: U = matrix(GF(13**2),[[1,4,7],[4,1,4],[7,4,1]])
+            sage: B = U._cholesky_extended_ff(); B
+            [        1         0         0]
+            [        4  7*z2 + 3         0]
+            [        7 6*z2 + 10 12*z2 + 6]
+            sage: U == B * B.H
+            True
+            sage: U = matrix(GF(7**2), [[0, 1, 2], [1, 0, 1], [2, 1, 0]])
+            sage: B = U._cholesky_extended_ff(); B
+            [4*z2 + 2     6*z2        0]
+            [4*z2 + 2       z2        0]
+            [5*z2 + 6       z2       z2]
+            sage: U == B * B.H
+            True
+
+        TESTS:
+
+        If the matrix is not full rank, we compute the rank and throw an exception.
+
+            sage: # needs sage.rings.finite_rings
+            sage: U = matrix(GF(3**2),[[1,4,7],[4,1,4],[7,4,1]])
+            sage: U._cholesky_extended_ff()
+            Traceback (most recent call last):
+            ...
+            ValueError: matrix is not full rank
+            sage: U = matrix(GF(3**2),[[0,4,7],[4,1,4],[7,4,1]])
+            sage: U._cholesky_extended_ff()
+            Traceback (most recent call last):
+            ...
+            ValueError: matrix is not full rank
+        """
+        from sage.matrix.constructor import identity_matrix
+
+        if not self.is_hermitian():
+            raise ValueError("matrix is not Hermitian")
+
+        F = self._base_ring
+        n = self.nrows()
+        if self.fetch("rank") not in [n, None]:
+            raise ValueError("matrix is not full rank")
+        if not (F.is_finite() and F.order().is_square()):
+            raise ValueError("the base ring must be a finite field of square order")
+
+        q = F.order().sqrt(extend=False)
+
+        def conj_square_root(u):
+            if u == 0:
+                return 0
+            z = F.multiplicative_generator()
+            k = u.log(z)
+            if k % (q + 1) != 0:
+                raise ValueError(f"unable to factor: {u} is not in base field GF({q})")
+            return z ** (k//(q+1))
+
+        if self.nrows() == 1 and self.ncols() == 1:
+            return self.__class__(F, [conj_square_root(self[0][0])])
+
+        A = copy(self)
+        D = identity_matrix(F, n)
+        row = -1
+
+        # Diagonalize A
+        while row != n - 1:
+            row += 1
+
+            # Look for a non-zero element on the main diagonal, starting from `row`
+            i = row
+            while i < n and A[i, i].is_zero():
+                i += 1
+
+            if i == row:
+                # Do nothing since A[row, row] != 0
+                pass
+            elif i < n:
+                # Swap to ensure A[row, row] != 0
+                A.swap_rows(row, i)
+                A.swap_columns(row, i)
+                D.swap_rows(row, i)
+            else:
+                # All entries on the main diagonal are zero; look for an off-diagonal element
+                i = row
+                while i < n - 1:
+                    k = i + 1
+                    while k < n and A[i, k].is_zero():
+                        k += 1
+                    if k == n:
+                        i += 1
+                    else:
+                        break
+
+                if i == n - 1:
+                    # All elements are zero; terminate
+                    row -= 1
+                    r = row + 1
+                    break
+
+                # Fetch the non-zero element and place it at A[row, row + 1]
+                if i != row:
+                    A.swap_rows(row, i)
+                    A.swap_columns(row, i)
+                    D.swap_rows(row, i)
+
+                A.swap_rows(row + 1, k)
+                A.swap_columns(row + 1, k)
+                D.swap_rows(row + 1, k)
+
+                b = ~A[row + 1, row]
+                A.add_multiple_of_column(row, row + 1, b**q)
+                A.add_multiple_of_row(row, row + 1, b)
+                D.add_multiple_of_row(row, row + 1, b)
+
+            # Eliminate below-diagonal entries in the current column
+            a = ~(-A[row, row])
+            for i in range(row + 1, n):
+                b = A[i, row] * a
+                if not b.is_zero():
+                    A.add_multiple_of_column(i, row, b**q)
+                    A.add_multiple_of_row(i, row, b)
+                    D.add_multiple_of_row(i, row, b)
+
+        # Count how many variables have been used
+        if row == n - 1:
+            if A[n - 1, n - 1]:  # nonzero entry
+                r = n
+            else:
+                r = n - 1
+
+        if r < n:
+            self.cache('rank', r)
+            raise ValueError("matrix is not full rank")
+
+        # Normalize diagonal elements to 1
+        for i in range(r):
+            a = A[i, i]
+            if not a.is_one():
+                # Find an element `b` such that `a = b*b^q = b^(q+1)`
+                b = conj_square_root(a)
+                D.rescale_row(i, 1 / b)
+
+        return D.inverse()
+
+    def cholesky(self, extended=False):
         r"""
         Return the Cholesky decomposition of a Hermitian matrix.
 
@@ -13001,6 +13600,15 @@ cdef class Matrix(Matrix1):
         closure or the algebraic reals, depending on whether or not
         imaginary numbers are required.
 
+        Over finite fields, the Cholesky decomposition might
+        not exist, but when the field has square order (i.e.,
+        `\GF{q^2}`), then we can perform the conjugate-symmetric
+        version of Gaussian elimination, but the resulting
+        decomposition matrix `L` might not be lower triangular.
+
+        This is a translation of ``BaseChangeToCanonical`` from
+        the GAP ``forms`` package (for a Hermitian form).
+
         EXAMPLES:
 
         This simple example has a result with entries that remain
@@ -13171,6 +13779,31 @@ cdef class Matrix(Matrix1):
             ...
             ValueError: matrix is not positive definite
 
+        Here we use the extended decomposition, where the result
+        may not be a lower triangular matrix::
+
+            sage: # needs sage.rings.finite_rings
+            sage: U = matrix(GF(5**2),[[0,1],[1,0]])
+            sage: B = U.cholesky(extended=True); B
+            [3*z2 4*z2]
+            [3*z2   z2]
+            sage: U == B * B.H
+            True
+            sage: U = matrix(GF(11**2),[[1,4,7],[4,1,4],[7,4,1]])
+            sage: B = U.cholesky(extended=True); B
+            [        1         0         0]
+            [        4  9*z2 + 2         0]
+            [        7 10*z2 + 1  3*z2 + 3]
+            sage: U == B * B.H
+            True
+            sage: U = matrix(GF(3**2), [[0, 1, 2], [1, 0, 1], [2, 1, 0]])
+            sage: B = U.cholesky(extended=True); B
+            [2*z2    2    0]
+            [2*z2    1    0]
+            [   0    1   z2]
+            sage: U == B * B.H
+            True
+
         TESTS:
 
         This verifies that :issue:`11274` is resolved::
@@ -13217,7 +13850,22 @@ cdef class Matrix(Matrix1):
             sage: all( matrix(R,[]).cholesky().is_immutable()                           # needs sage.rings.number_field
             ....:      for R in (RR,CC,RDF,CDF,ZZ,QQ,AA,QQbar) )
             True
+
+        Perform the extended decomposition over finite fields, which may result in non upper/lower triangular matrices::
+
+            sage: # needs sage.rings.finite_rings
+            sage: A = matrix(GF(11**2),[[1,4,7],[4,1,4],[7,4,1]])
+            sage: B = A.cholesky(extended=True)
+            sage: A == B * B.H
+            True
+            sage: A = matrix(GF(3**2), [[0, 1, 2], [1, 0, 1], [2, 1, 0]])
+            sage: B = A.cholesky(extended=True)
+            sage: A == B * B.H
+            True
         """
+        if extended:
+            return self._cholesky_extended_ff()
+
         cdef Matrix C  # output matrix
         C = self.fetch('cholesky')
         if C is not None:
@@ -15476,6 +16124,10 @@ cdef class Matrix(Matrix1):
         Return the conjugate of self, i.e. the matrix whose entries are the
         conjugates of the entries of ``self``.
 
+        .. SEEALSO::
+
+            :attr:`C`
+
         EXAMPLES::
 
             sage: # needs sage.rings.complex_double sage.symbolic
@@ -15531,6 +16183,10 @@ cdef class Matrix(Matrix1):
             though there is substantial variation and some confusion with
             the use of that term.
 
+        .. SEEALSO::
+
+            :meth:`conjugate`, :meth:`~.Matrix_dense.transpose`, :attr:`H`
+
         OUTPUT:
 
         A matrix formed by taking the complex conjugate of every entry
@@ -15958,7 +16614,11 @@ cdef class Matrix(Matrix1):
         """
         d = self.smith_form(transformation=False)
         r = min(self.nrows(), self.ncols())
-        return [d[i, i] for i in range(r)]
+        ed = [d[i, i] for i in range(r)]
+        try:
+            return [x.canonical_associate()[0] for x in ed]
+        except (AttributeError, TypeError):
+            return ed
 
     def smith_form(self, transformation=True, integral=None, exact=True):
         r"""
@@ -16138,7 +16798,7 @@ cdef class Matrix(Matrix1):
             sage: d, u, v = m.smith_form(); u * m * v == d
             True
 
-        Over local fields, we can request the transformation matrices to be integral:;
+        Over local fields, we can request the transformation matrices to be integral::
 
             sage: K = Qp(2, 5, print_mode='terse')                                      # needs sage.rings.padics
             sage: M = matrix(K, 2, 3, [1/2, 1, 2, 1/3, 1, 3])                           # needs sage.rings.padics
@@ -18229,11 +18889,11 @@ cdef class Matrix(Matrix1):
         the greatest common divisor of the determinants of all `r`-by-`r`
         submatrices of `B` is `1`. [Sch1986]_, Ch. 21.4.
 
-        .. SEEALSO:: :meth:`is_k_equimodular`, :meth:`is_strongly_unimodular`, :meth:`is_totally_unimodular`
-
-        See :meth:`~sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_unimodular` for
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_unimodular` for
         the detailed documentation.
 
+        .. SEEALSO:: :meth:`is_k_equimodular`, :meth:`is_strongly_unimodular`, :meth:`is_totally_unimodular`
+
         EXAMPLES::
 
             sage: # needs sage.libs.cmr
@@ -18256,7 +18916,10 @@ cdef class Matrix(Matrix1):
 
         A matrix is strongly unimodular if ``self`` and ``self.transpose()`` are both unimodular.
 
-        .. SEEALSO:: meth:`is_unimodular`, :meth:`is_strongly_k_equimodular`
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_strongly_unimodular` for
+        the detailed documentation.
+
+        .. SEEALSO:: :meth:`is_unimodular`, :meth:`is_strongly_k_equimodular`
 
         EXAMPLES::
 
@@ -18295,6 +18958,9 @@ cdef class Matrix(Matrix1):
         - ``k``: ``self`` is equimodular with determinant gcd `k`
         - ``None``: ``self`` is not equimodular for any `k`
 
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.equimodulus` for
+        the detailed documentation.
+
         .. SEEALSO:: :meth:`is_k_equimodular`, :meth:`strong_equimodulus`
 
         EXAMPLES::
@@ -18336,6 +19002,9 @@ cdef class Matrix(Matrix1):
         - ``k``: ``self`` is  `k`-equimodular
         - ``None``: ``self`` is not `k`-equimodular for any `k`
 
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.strong_equimodulus` for
+        the detailed documentation.
+
         .. SEEALSO:: :meth:`is_strongly_k_equimodular`, :meth:`equimodulus`
 
         EXAMPLES::
@@ -18374,6 +19043,9 @@ cdef class Matrix(Matrix1):
             In parts of the literature, a matrix with the above properties
             is called *strictly* `k`-modular.
 
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_k_equimodular` for
+        the detailed documentation.
+
         .. SEEALSO:: :meth:`is_unimodular`, :meth:`is_strongly_k_equimodular`,
                      :meth:`equimodulus`
 
@@ -18403,6 +19075,9 @@ cdef class Matrix(Matrix1):
         A matrix is strongly `k`-equimodular if ``self`` and ``self.transpose()``
         are both `k`-equimodular.
 
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_strongly_k_equimodular` for
+        the detailed documentation.
+
         .. SEEALSO:: :meth:`is_k_equimodular`, :meth:`is_strongly_unimodular`,
                      :meth:`strong_equimodulus`
 
@@ -18452,6 +19127,9 @@ cdef class Matrix(Matrix1):
         the support matrix of `M` for being graphic and
         uses camion for testing whether `M` is signed correctly.
 
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_network_matrix` for
+        the detailed documentation.
+
         EXAMPLES::
 
             sage: # needs sage.libs.cmr
@@ -18523,11 +19201,14 @@ cdef class Matrix(Matrix1):
 
     def is_conetwork_matrix(self, *args, **kwds):
         r"""
-        Return whether the matrix ``self`` over `\GF{3}` or `QQ` is a conetwork matrix.
+        Return whether the matrix ``self`` over `\GF{3}` or `\QQ` is a conetwork matrix.
 
-        A matrix is conetwork if and only if its transpose is network.
+        A matrix is a conetwork matrix if and only if its transpose is a network matrix.
+
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_conetwork_matrix` for
+        the detailed documentation.
 
-        .. SEEALSO:: :meth:`is_network_matrix`,
+        .. SEEALSO:: :meth:`is_network_matrix`
 
         EXAMPLES::
 
@@ -18586,14 +19267,15 @@ cdef class Matrix(Matrix1):
         - ``stop_when_nonTU`` -- boolean (default: ``True``);
           whether to stop decomposing once not TU is determined.
 
-          For a description of other parameters, see :meth:`_set_cmr_seymour_parameters`
-
         - ``row_keys`` -- a finite or enumerated family of arbitrary objects
           that index the rows of the matrix
 
         - ``column_keys`` -- a finite or enumerated family of arbitrary objects
           that index the columns of the matrix
 
+        See :meth:`sage.matrix.matrix_cmr_sparse.Matrix_cmr_sparse.is_totally_unimodular` for
+        the detailed documentation.
+
         EXAMPLES::
 
             sage: # needs sage.libs.cmr
@@ -18667,8 +19349,8 @@ cdef class Matrix(Matrix1):
             │                 │
             GraphicNode (5×4) CographicNode (4×5)
 
-        This is test ``TreeFlagsNorecurse``, ``TreeFlagsStopNoncographic``,
-        and ``TreeFlagsStopNongraphic`` in CMR's ``test_regular.cpp``,
+        These are tests ``TreeFlagsNorecurse``, ``TreeFlagsStopNoncographic``,
+        and ``TreeFlagsStopNongraphic`` in CMR's ``test_regular.cpp``;
         the underlying binary linear matroid is regular,
         but the matrix is not totally unimodular::
 
@@ -18701,9 +19383,6 @@ cdef class Matrix(Matrix1):
         """
         return self._matrix_cmr().is_totally_unimodular(*args, **kwds)
 
-    def is_complement_totally_unimodular(self, *args, **kwds):
-        return self._matrix_cmr().is_complement_totally_unimodular(*args, **kwds)
-
     def LLL_gram(self, flag=0):
         """
         Return the LLL transformation matrix for this Gram matrix.
@@ -18865,6 +19544,10 @@ cdef class Matrix(Matrix1):
         r"""
         Return the conjugate-transpose (Hermitian) matrix.
 
+        .. SEEALSO::
+
+            :meth:`conjugate_transpose`
+
         EXAMPLES::
 
             sage: A = matrix(QQbar, [[     -3,  5 - 3*I, 7 - 4*I],                      # needs sage.rings.number_field
@@ -18875,7 +19558,7 @@ cdef class Matrix(Matrix1):
             [ 5 + 3*I -1 - 6*I -3 - 6*I]
             [ 7 + 4*I  3 - 5*I  5 - 1*I]
         """
-        return self.conjugate().transpose()
+        return self.conjugate_transpose()
 
 
 def _smith_diag(d, transformation=True):