add read me

venv/lib/python3.12/site-packages/sympy/polys/matrices/__init__.py

@@ -0,0 +1,15 @@
+"""
+
+sympy.polys.matrices package.
+
+The main export from this package is the DomainMatrix class which is a
+lower-level implementation of matrices based on the polys Domains. This
+implementation is typically a lot faster than SymPy's standard Matrix class
+but is a work in progress and is still experimental.
+
+"""
+from .domainmatrix import DomainMatrix, DM
+
+__all__ = [
+    'DomainMatrix', 'DM',
+]

venv/lib/python3.12/site-packages/sympy/polys/matrices/_dfm.py

@@ -0,0 +1,951 @@
+#
+# sympy.polys.matrices.dfm
+#
+# This modules defines the DFM class which is a wrapper for dense flint
+# matrices as found in python-flint.
+#
+# As of python-flint 0.4.1 matrices over the following domains can be supported
+# by python-flint:
+#
+#   ZZ: flint.fmpz_mat
+#   QQ: flint.fmpq_mat
+#   GF(p): flint.nmod_mat (p prime and p < ~2**62)
+#
+# The underlying flint library has many more domains, but these are not yet
+# supported by python-flint.
+#
+# The DFM class is a wrapper for the flint matrices and provides a common
+# interface for all supported domains that is interchangeable with the DDM
+# and SDM classes so that DomainMatrix can be used with any as its internal
+# matrix representation.
+#
+
+# TODO:
+#
+# Implement the following methods that are provided by python-flint:
+#
+# - hnf (Hermite normal form)
+# - snf (Smith normal form)
+# - minpoly
+# - is_hnf
+# - is_snf
+# - rank
+#
+# The other types DDM and SDM do not have these methods and the algorithms
+# for hnf, snf and rank are already implemented. Algorithms for minpoly,
+# is_hnf and is_snf would need to be added.
+#
+# Add more methods to python-flint to expose more of Flint's functionality
+# and also to make some of the above methods simpler or more efficient e.g.
+# slicing, fancy indexing etc.
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.external.importtools import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from sympy.polys.domains import ZZ, QQ
+
+from .exceptions import (
+    DMBadInputError,
+    DMDomainError,
+    DMNonSquareMatrixError,
+    DMNonInvertibleMatrixError,
+    DMRankError,
+    DMShapeError,
+    DMValueError,
+)
+
+
+if GROUND_TYPES != 'flint':
+    __doctest_skip__ = ['*']
+
+
+flint = import_module('flint')
+
+
+__all__ = ['DFM']
+
+
+@doctest_depends_on(ground_types=['flint'])
+class DFM:
+    """
+    Dense FLINT matrix. This class is a wrapper for matrices from python-flint.
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.matrices.dfm import DFM
+    >>> dfm = DFM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    >>> dfm
+    [[1, 2], [3, 4]]
+    >>> dfm.rep
+    [1, 2]
+    [3, 4]
+    >>> type(dfm.rep)  # doctest: +SKIP
+    <class 'flint._flint.fmpz_mat'>
+
+    Usually, the DFM class is not instantiated directly, but is created as the
+    internal representation of :class:`~.DomainMatrix`. When
+    `SYMPY_GROUND_TYPES` is set to `flint` and `python-flint` is installed, the
+    :class:`DFM` class is used automatically as the internal representation of
+    :class:`~.DomainMatrix` in dense format if the domain is supported by
+    python-flint.
+
+    >>> from sympy.polys.matrices.domainmatrix import DM
+    >>> dM = DM([[1, 2], [3, 4]], ZZ)
+    >>> dM.rep
+    [[1, 2], [3, 4]]
+
+    A :class:`~.DomainMatrix` can be converted to :class:`DFM` by calling the
+    :meth:`to_dfm` method:
+
+    >>> dM.to_dfm()
+    [[1, 2], [3, 4]]
+
+    """
+
+    fmt = 'dense'
+    is_DFM = True
+    is_DDM = False
+
+    def __new__(cls, rowslist, shape, domain):
+        """Construct from a nested list."""
+        flint_mat = cls._get_flint_func(domain)
+
+        if 0 not in shape:
+            try:
+                rep = flint_mat(rowslist)
+            except (ValueError, TypeError):
+                raise DMBadInputError(f"Input should be a list of list of {domain}")
+        else:
+            rep = flint_mat(*shape)
+
+        return cls._new(rep, shape, domain)
+
+    @classmethod
+    def _new(cls, rep, shape, domain):
+        """Internal constructor from a flint matrix."""
+        cls._check(rep, shape, domain)
+        obj = object.__new__(cls)
+        obj.rep = rep
+        obj.shape = obj.rows, obj.cols = shape
+        obj.domain = domain
+        return obj
+
+    def _new_rep(self, rep):
+        """Create a new DFM with the same shape and domain but a new rep."""
+        return self._new(rep, self.shape, self.domain)
+
+    @classmethod
+    def _check(cls, rep, shape, domain):
+        repshape = (rep.nrows(), rep.ncols())
+        if repshape != shape:
+            raise DMBadInputError("Shape of rep does not match shape of DFM")
+        if domain == ZZ and not isinstance(rep, flint.fmpz_mat):
+            raise RuntimeError("Rep is not a flint.fmpz_mat")
+        elif domain == QQ and not isinstance(rep, flint.fmpq_mat):
+            raise RuntimeError("Rep is not a flint.fmpq_mat")
+        elif domain.is_FF and not isinstance(rep, (flint.fmpz_mod_mat, flint.nmod_mat)):
+            raise RuntimeError("Rep is not a flint.fmpz_mod_mat or flint.nmod_mat")
+        elif domain not in (ZZ, QQ) and not domain.is_FF:
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    @classmethod
+    def _supports_domain(cls, domain):
+        """Return True if the given domain is supported by DFM."""
+        return domain in (ZZ, QQ) or domain.is_FF and domain._is_flint
+
+    @classmethod
+    def _get_flint_func(cls, domain):
+        """Return the flint matrix class for the given domain."""
+        if domain == ZZ:
+            return flint.fmpz_mat
+        elif domain == QQ:
+            return flint.fmpq_mat
+        elif domain.is_FF:
+            c = domain.characteristic()
+            if isinstance(domain.one, flint.nmod):
+                _cls = flint.nmod_mat
+                def _func(*e):
+                    if len(e) == 1 and isinstance(e[0], flint.nmod_mat):
+                        return _cls(e[0])
+                    else:
+                        return _cls(*e, c)
+            else:
+                m = flint.fmpz_mod_ctx(c)
+                _func = lambda *e: flint.fmpz_mod_mat(*e, m)
+            return _func
+        else:
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    @property
+    def _func(self):
+        """Callable to create a flint matrix of the same domain."""
+        return self._get_flint_func(self.domain)
+
+    def __str__(self):
+        """Return ``str(self)``."""
+        return str(self.to_ddm())
+
+    def __repr__(self):
+        """Return ``repr(self)``."""
+        return f'DFM{repr(self.to_ddm())[3:]}'
+
+    def __eq__(self, other):
+        """Return ``self == other``."""
+        if not isinstance(other, DFM):
+            return NotImplemented
+        # Compare domains first because we do *not* want matrices with
+        # different domains to be equal but e.g. a flint fmpz_mat and fmpq_mat
+        # with the same entries will compare equal.
+        return self.domain == other.domain and self.rep == other.rep
+
+    @classmethod
+    def from_list(cls, rowslist, shape, domain):
+        """Construct from a nested list."""
+        return cls(rowslist, shape, domain)
+
+    def to_list(self):
+        """Convert to a nested list."""
+        return self.rep.tolist()
+
+    def copy(self):
+        """Return a copy of self."""
+        return self._new_rep(self._func(self.rep))
+
+    def to_ddm(self):
+        """Convert to a DDM."""
+        return DDM.from_list(self.to_list(), self.shape, self.domain)
+
+    def to_sdm(self):
+        """Convert to a SDM."""
+        return SDM.from_list(self.to_list(), self.shape, self.domain)
+
+    def to_dfm(self):
+        """Return self."""
+        return self
+
+    def to_dfm_or_ddm(self):
+        """
+        Convert to a :class:`DFM`.
+
+        This :class:`DFM` method exists to parallel the :class:`~.DDM` and
+        :class:`~.SDM` methods. For :class:`DFM` it will always return self.
+
+        See Also
+        ========
+
+        to_ddm
+        to_sdm
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm
+        """
+        return self
+
+    @classmethod
+    def from_ddm(cls, ddm):
+        """Convert from a DDM."""
+        return cls.from_list(ddm.to_list(), ddm.shape, ddm.domain)
+
+    @classmethod
+    def from_list_flat(cls, elements, shape, domain):
+        """Inverse of :meth:`to_list_flat`."""
+        func = cls._get_flint_func(domain)
+        try:
+            rep = func(*shape, elements)
+        except ValueError:
+            raise DMBadInputError(f"Incorrect number of elements for shape {shape}")
+        except TypeError:
+            raise DMBadInputError(f"Input should be a list of {domain}")
+        return cls(rep, shape, domain)
+
+    def to_list_flat(self):
+        """Convert to a flat list."""
+        return self.rep.entries()
+
+    def to_flat_nz(self):
+        """Convert to a flat list of non-zeros."""
+        return self.to_ddm().to_flat_nz()
+
+    @classmethod
+    def from_flat_nz(cls, elements, data, domain):
+        """Inverse of :meth:`to_flat_nz`."""
+        return DDM.from_flat_nz(elements, data, domain).to_dfm()
+
+    def to_dod(self):
+        """Convert to a DOD."""
+        return self.to_ddm().to_dod()
+
+    @classmethod
+    def from_dod(cls, dod, shape, domain):
+        """Inverse of :meth:`to_dod`."""
+        return DDM.from_dod(dod, shape, domain).to_dfm()
+
+    def to_dok(self):
+        """Convert to a DOK."""
+        return self.to_ddm().to_dok()
+
+    @classmethod
+    def from_dok(cls, dok, shape, domain):
+        """Inverse of :math:`to_dod`."""
+        return DDM.from_dok(dok, shape, domain).to_dfm()
+
+    def iter_values(self):
+        """Iterate over the non-zero values of the matrix."""
+        m, n = self.shape
+        rep = self.rep
+        for i in range(m):
+            for j in range(n):
+                repij = rep[i, j]
+                if repij:
+                    yield rep[i, j]
+
+    def iter_items(self):
+        """Iterate over indices and values of nonzero elements of the matrix."""
+        m, n = self.shape
+        rep = self.rep
+        for i in range(m):
+            for j in range(n):
+                repij = rep[i, j]
+                if repij:
+                    yield ((i, j), repij)
+
+    def convert_to(self, domain):
+        """Convert to a new domain."""
+        if domain == self.domain:
+            return self.copy()
+        elif domain == QQ and self.domain == ZZ:
+            return self._new(flint.fmpq_mat(self.rep), self.shape, domain)
+        elif self._supports_domain(domain):
+            # XXX: Use more efficient conversions when possible.
+            return self.to_ddm().convert_to(domain).to_dfm()
+        else:
+            # It is the callers responsibility to convert to DDM before calling
+            # this method if the domain is not supported by DFM.
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    def getitem(self, i, j):
+        """Get the ``(i, j)``-th entry."""
+        # XXX: flint matrices do not support negative indices
+        # XXX: They also raise ValueError instead of IndexError
+        m, n = self.shape
+        if i < 0:
+            i += m
+        if j < 0:
+            j += n
+        try:
+            return self.rep[i, j]
+        except ValueError:
+            raise IndexError(f"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}")
+
+    def setitem(self, i, j, value):
+        """Set the ``(i, j)``-th entry."""
+        # XXX: flint matrices do not support negative indices
+        # XXX: They also raise ValueError instead of IndexError
+        m, n = self.shape
+        if i < 0:
+            i += m
+        if j < 0:
+            j += n
+        try:
+            self.rep[i, j] = value
+        except ValueError:
+            raise IndexError(f"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}")
+
+    def _extract(self, i_indices, j_indices):
+        """Extract a submatrix with no checking."""
+        # Indices must be positive and in range.
+        M = self.rep
+        lol = [[M[i, j] for j in j_indices] for i in i_indices]
+        shape = (len(i_indices), len(j_indices))
+        return self.from_list(lol, shape, self.domain)
+
+    def extract(self, rowslist, colslist):
+        """Extract a submatrix."""
+        # XXX: flint matrices do not support fancy indexing or negative indices
+        #
+        # Check and convert negative indices before calling _extract.
+        m, n = self.shape
+
+        new_rows = []
+        new_cols = []
+
+        for i in rowslist:
+            if i < 0:
+                i_pos = i + m
+            else:
+                i_pos = i
+            if not 0 <= i_pos < m:
+                raise IndexError(f"Invalid row index {i} for Matrix of shape {self.shape}")
+            new_rows.append(i_pos)
+
+        for j in colslist:
+            if j < 0:
+                j_pos = j + n
+            else:
+                j_pos = j
+            if not 0 <= j_pos < n:
+                raise IndexError(f"Invalid column index {j} for Matrix of shape {self.shape}")
+            new_cols.append(j_pos)
+
+        return self._extract(new_rows, new_cols)
+
+    def extract_slice(self, rowslice, colslice):
+        """Slice a DFM."""
+        # XXX: flint matrices do not support slicing
+        m, n = self.shape
+        i_indices = range(m)[rowslice]
+        j_indices = range(n)[colslice]
+        return self._extract(i_indices, j_indices)
+
+    def neg(self):
+        """Negate a DFM matrix."""
+        return self._new_rep(-self.rep)
+
+    def add(self, other):
+        """Add two DFM matrices."""
+        return self._new_rep(self.rep + other.rep)
+
+    def sub(self, other):
+        """Subtract two DFM matrices."""
+        return self._new_rep(self.rep - other.rep)
+
+    def mul(self, other):
+        """Multiply a DFM matrix from the right by a scalar."""
+        return self._new_rep(self.rep * other)
+
+    def rmul(self, other):
+        """Multiply a DFM matrix from the left by a scalar."""
+        return self._new_rep(other * self.rep)
+
+    def mul_elementwise(self, other):
+        """Elementwise multiplication of two DFM matrices."""
+        # XXX: flint matrices do not support elementwise multiplication
+        return self.to_ddm().mul_elementwise(other.to_ddm()).to_dfm()
+
+    def matmul(self, other):
+        """Multiply two DFM matrices."""
+        shape = (self.rows, other.cols)
+        return self._new(self.rep * other.rep, shape, self.domain)
+
+    # XXX: For the most part DomainMatrix does not expect DDM, SDM, or DFM to
+    # have arithmetic operators defined. The only exception is negation.
+    # Perhaps that should be removed.
+
+    def __neg__(self):
+        """Negate a DFM matrix."""
+        return self.neg()
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        """Return a zero DFM matrix."""
+        func = cls._get_flint_func(domain)
+        return cls._new(func(*shape), shape, domain)
+
+    # XXX: flint matrices do not have anything like ones or eye
+    # In the methods below we convert to DDM and then back to DFM which is
+    # probably about as efficient as implementing these methods directly.
+
+    @classmethod
+    def ones(cls, shape, domain):
+        """Return a one DFM matrix."""
+        # XXX: flint matrices do not have anything like ones
+        return DDM.ones(shape, domain).to_dfm()
+
+    @classmethod
+    def eye(cls, n, domain):
+        """Return the identity matrix of size n."""
+        # XXX: flint matrices do not have anything like eye
+        return DDM.eye(n, domain).to_dfm()
+
+    @classmethod
+    def diag(cls, elements, domain):
+        """Return a diagonal matrix."""
+        return DDM.diag(elements, domain).to_dfm()
+
+    def applyfunc(self, func, domain):
+        """Apply a function to each entry of a DFM matrix."""
+        return self.to_ddm().applyfunc(func, domain).to_dfm()
+
+    def transpose(self):
+        """Transpose a DFM matrix."""
+        return self._new(self.rep.transpose(), (self.cols, self.rows), self.domain)
+
+    def hstack(self, *others):
+        """Horizontally stack matrices."""
+        return self.to_ddm().hstack(*[o.to_ddm() for o in others]).to_dfm()
+
+    def vstack(self, *others):
+        """Vertically stack matrices."""
+        return self.to_ddm().vstack(*[o.to_ddm() for o in others]).to_dfm()
+
+    def diagonal(self):
+        """Return the diagonal of a DFM matrix."""
+        M = self.rep
+        m, n = self.shape
+        return [M[i, i] for i in range(min(m, n))]
+
+    def is_upper(self):
+        """Return ``True`` if the matrix is upper triangular."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(min(i, self.cols)):
+                if M[i, j]:
+                    return False
+        return True
+
+    def is_lower(self):
+        """Return ``True`` if the matrix is lower triangular."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(i + 1, self.cols):
+                if M[i, j]:
+                    return False
+        return True
+
+    def is_diagonal(self):
+        """Return ``True`` if the matrix is diagonal."""
+        return self.is_upper() and self.is_lower()
+
+    def is_zero_matrix(self):
+        """Return ``True`` if the matrix is the zero matrix."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if M[i, j]:
+                    return False
+        return True
+
+    def nnz(self):
+        """Return the number of non-zero elements in the matrix."""
+        return self.to_ddm().nnz()
+
+    def scc(self):
+        """Return the strongly connected components of the matrix."""
+        return self.to_ddm().scc()
+
+    @doctest_depends_on(ground_types='flint')
+    def det(self):
+        """
+        Compute the determinant of the matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm()
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.det()
+        -2
+
+        Notes
+        =====
+
+        Calls the ``.det()`` method of the underlying FLINT matrix.
+
+        For :ref:`ZZ` or :ref:`QQ` this calls ``fmpz_mat_det`` or
+        ``fmpq_mat_det`` respectively.
+
+        At the time of writing the implementation of ``fmpz_mat_det`` uses one
+        of several algorithms depending on the size of the matrix and bit size
+        of the entries. The algorithms used are:
+
+        - Cofactor for very small (up to 4x4) matrices.
+        - Bareiss for small (up to 25x25) matrices.
+        - Modular algorithms for larger matrices (up to 60x60) or for larger
+          matrices with large bit sizes.
+        - Modular "accelerated" for larger matrices (60x60 upwards) if the bit
+          size is smaller than the dimensions of the matrix.
+
+        The implementation of ``fmpq_mat_det`` clears denominators from each
+        row (not the whole matrix) and then calls ``fmpz_mat_det`` and divides
+        by the product of the denominators.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.det
+            Higher level interface to compute the determinant of a matrix.
+        """
+        # XXX: At least the first three algorithms described above should also
+        # be implemented in the pure Python DDM and SDM classes which at the
+        # time of writng just use Bareiss for all matrices and domains.
+        # Probably in Python the thresholds would be different though.
+        return self.rep.det()
+
+    @doctest_depends_on(ground_types='flint')
+    def charpoly(self):
+        """
+        Compute the characteristic polynomial of the matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm()  # need ground types = 'flint'
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.charpoly()
+        [1, -5, -2]
+
+        Notes
+        =====
+
+        Calls the ``.charpoly()`` method of the underlying FLINT matrix.
+
+        For :ref:`ZZ` or :ref:`QQ` this calls ``fmpz_mat_charpoly`` or
+        ``fmpq_mat_charpoly`` respectively.
+
+        At the time of writing the implementation of ``fmpq_mat_charpoly``
+        clears a denominator from the whole matrix and then calls
+        ``fmpz_mat_charpoly``. The coefficients of the characteristic
+        polynomial are then multiplied by powers of the denominator.
+
+        The ``fmpz_mat_charpoly`` method uses a modular algorithm with CRT
+        reconstruction. The modular algorithm uses ``nmod_mat_charpoly`` which
+        uses Berkowitz for small matrices and non-prime moduli or otherwise
+        the Danilevsky method.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly
+            Higher level interface to compute the characteristic polynomial of
+            a matrix.
+        """
+        # FLINT polynomial coefficients are in reverse order compared to SymPy.
+        return self.rep.charpoly().coeffs()[::-1]
+
+    @doctest_depends_on(ground_types='flint')
+    def inv(self):
+        """
+        Compute the inverse of a matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, QQ
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm().convert_to(QQ)
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.inv()
+        [[-2, 1], [3/2, -1/2]]
+        >>> dfm.matmul(dfm.inv())
+        [[1, 0], [0, 1]]
+
+        Notes
+        =====
+
+        Calls the ``.inv()`` method of the underlying FLINT matrix.
+
+        For now this will raise an error if the domain is :ref:`ZZ` but will
+        use the FLINT method for :ref:`QQ`.
+
+        The FLINT methods for :ref:`ZZ` and :ref:`QQ` are ``fmpz_mat_inv`` and
+        ``fmpq_mat_inv`` respectively. The ``fmpz_mat_inv`` method computes an
+        inverse with denominator. This is implemented by calling
+        ``fmpz_mat_solve`` (see notes in :meth:`lu_solve` about the algorithm).
+
+        The ``fmpq_mat_inv`` method clears denominators from each row and then
+        multiplies those into the rhs identity matrix before calling
+        ``fmpz_mat_solve``.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.inv
+            Higher level method for computing the inverse of a matrix.
+        """
+        # TODO: Implement similar algorithms for DDM and SDM.
+        #
+        # XXX: The flint fmpz_mat and fmpq_mat inv methods both return fmpq_mat
+        # by default. The fmpz_mat method has an optional argument to return
+        # fmpz_mat instead for unimodular matrices.
+        #
+        # The convention in DomainMatrix is to raise an error if the matrix is
+        # not over a field regardless of whether the matrix is invertible over
+        # its domain or over any associated field. Maybe DomainMatrix.inv
+        # should be changed to always return a matrix over an associated field
+        # except with a unimodular argument for returning an inverse over a
+        # ring if possible.
+        #
+        # For now we follow the existing DomainMatrix convention...
+        K = self.domain
+        m, n = self.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("cannot invert a non-square matrix")
+
+        if K == ZZ:
+            raise DMDomainError("field expected, got %s" % K)
+        elif K == QQ or K.is_FF:
+            try:
+                return self._new_rep(self.rep.inv())
+            except ZeroDivisionError:
+                raise DMNonInvertibleMatrixError("matrix is not invertible")
+        else:
+            # If more domains are added for DFM then we will need to consider
+            # what happens here.
+            raise NotImplementedError("DFM.inv() is not implemented for %s" % K)
+
+    def lu(self):
+        """Return the LU decomposition of the matrix."""
+        L, U, swaps = self.to_ddm().lu()
+        return L.to_dfm(), U.to_dfm(), swaps
+
+    def qr(self):
+        """Return the QR decomposition of the matrix."""
+        Q, R = self.to_ddm().qr()
+        return Q.to_dfm(), R.to_dfm()
+
+    # XXX: The lu_solve function should be renamed to solve. Whether or not it
+    # uses an LU decomposition is an implementation detail. A method called
+    # lu_solve would make sense for a situation in which an LU decomposition is
+    # reused several times to solve with different rhs but that would imply a
+    # different call signature.
+    #
+    # The underlying python-flint method has an algorithm= argument so we could
+    # use that and have e.g. solve_lu and solve_modular or perhaps also a
+    # method= argument to choose between the two. Flint itself has more
+    # possible algorithms to choose from than are exposed by python-flint.
+
+    @doctest_depends_on(ground_types='flint')
+    def lu_solve(self, rhs):
+        """
+        Solve a matrix equation using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, QQ
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm().convert_to(QQ)
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> rhs = Matrix([1, 2]).to_DM().to_dfm().convert_to(QQ)
+        >>> dfm.lu_solve(rhs)
+        [[0], [1/2]]
+
+        Notes
+        =====
+
+        Calls the ``.solve()`` method of the underlying FLINT matrix.
+
+        For now this will raise an error if the domain is :ref:`ZZ` but will
+        use the FLINT method for :ref:`QQ`.
+
+        The FLINT methods for :ref:`ZZ` and :ref:`QQ` are ``fmpz_mat_solve``
+        and ``fmpq_mat_solve`` respectively. The ``fmpq_mat_solve`` method
+        uses one of two algorithms:
+
+        - For small matrices (<25 rows) it clears denominators between the
+          matrix and rhs and uses ``fmpz_mat_solve``.
+        - For larger matrices it uses ``fmpq_mat_solve_dixon`` which is a
+          modular approach with CRT reconstruction over :ref:`QQ`.
+
+        The ``fmpz_mat_solve`` method uses one of four algorithms:
+
+        - For very small (<= 3x3) matrices it uses a Cramer's rule.
+        - For small (<= 15x15) matrices it uses a fraction-free LU solve.
+        - Otherwise it uses either Dixon or another multimodular approach.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve
+            Higher level interface to solve a matrix equation.
+        """
+        if not self.domain == rhs.domain:
+            raise DMDomainError("Domains must match: %s != %s" % (self.domain, rhs.domain))
+
+        # XXX: As for inv we should consider whether to return a matrix over
+        # over an associated field or attempt to find a solution in the ring.
+        # For now we follow the existing DomainMatrix convention...
+        if not self.domain.is_Field:
+            raise DMDomainError("Field expected, got %s" % self.domain)
+
+        m, n = self.shape
+        j, k = rhs.shape
+        if m != j:
+            raise DMShapeError("Matrix size mismatch: %s * %s vs %s * %s" % (m, n, j, k))
+        sol_shape = (n, k)
+
+        # XXX: The Flint solve method only handles square matrices. Probably
+        # Flint has functions that could be used to solve non-square systems
+        # but they are not exposed in python-flint yet. Alternatively we could
+        # put something here using the features that are available like rref.
+        if m != n:
+            return self.to_ddm().lu_solve(rhs.to_ddm()).to_dfm()
+
+        try:
+            sol = self.rep.solve(rhs.rep)
+        except ZeroDivisionError:
+            raise DMNonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+        return self._new(sol, sol_shape, self.domain)
+
+    def fflu(self):
+        """
+        Fraction-free LU decomposition of DFM.
+
+        Explanation
+        ===========
+
+        Uses `python-flint` if possible for a matrix of
+        integers otherwise uses the DDM method.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.ddm.DDM.fflu
+        """
+        if self.domain == ZZ:
+            fflu = getattr(self.rep, 'fflu', None)
+            if fflu is not None:
+                P, L, D, U = self.rep.fflu()
+                m, n = self.shape
+                return (
+                    self._new(P, (m, m), self.domain),
+                    self._new(L, (m, m), self.domain),
+                    self._new(D, (m, m), self.domain),
+                    self._new(U, self.shape, self.domain)
+                )
+        ddm_p, ddm_l, ddm_d, ddm_u = self.to_ddm().fflu()
+        P = ddm_p.to_dfm()
+        L = ddm_l.to_dfm()
+        D = ddm_d.to_dfm()
+        U = ddm_u.to_dfm()
+        return P, L, D, U
+
+    def nullspace(self):
+        """Return a basis for the nullspace of the matrix."""
+        # Code to compute nullspace using flint:
+        #
+        # V, nullity = self.rep.nullspace()
+        # V_dfm = self._new_rep(V)._extract(range(self.rows), range(nullity))
+        #
+        # XXX: That gives the nullspace but does not give us nonpivots. So we
+        # use the slower DDM method anyway. It would be better to change the
+        # signature of the nullspace method to not return nonpivots.
+        #
+        # XXX: Also python-flint exposes a nullspace method for fmpz_mat but
+        # not for fmpq_mat. This is the reverse of the situation for DDM etc
+        # which only allow nullspace over a field. The nullspace method for
+        # DDM, SDM etc should be changed to allow nullspace over ZZ as well.
+        # The DomainMatrix nullspace method does allow the domain to be a ring
+        # but does not directly call the lower-level nullspace methods and uses
+        # rref_den instead. Nullspace methods should also be added to all
+        # matrix types in python-flint.
+        ddm, nonpivots = self.to_ddm().nullspace()
+        return ddm.to_dfm(), nonpivots
+
+    def nullspace_from_rref(self, pivots=None):
+        """Return a basis for the nullspace of the matrix."""
+        # XXX: Use the flint nullspace method!!!
+        sdm, nonpivots = self.to_sdm().nullspace_from_rref(pivots=pivots)
+        return sdm.to_dfm(), nonpivots
+
+    def particular(self):
+        """Return a particular solution to the system."""
+        return self.to_ddm().particular().to_dfm()
+
+    def _lll(self, transform=False, delta=0.99, eta=0.51, rep='zbasis', gram='approx'):
+        """Call the fmpz_mat.lll() method but check rank to avoid segfaults."""
+
+        # XXX: There are tests that pass e.g. QQ(5,6) for delta. That fails
+        # with a TypeError in flint because if QQ is fmpq then conversion with
+        # float fails. We handle that here but there are two better fixes:
+        #
+        # - Make python-flint's fmpq convert with float(x)
+        # - Change the tests because delta should just be a float.
+
+        def to_float(x):
+            if QQ.of_type(x):
+                return float(x.numerator) / float(x.denominator)
+            else:
+                return float(x)
+
+        delta = to_float(delta)
+        eta = to_float(eta)
+
+        if not 0.25 < delta < 1:
+            raise DMValueError("delta must be between 0.25 and 1")
+
+        # XXX: The flint lll method segfaults if the matrix is not full rank.
+        m, n = self.shape
+        if self.rep.rank() != m:
+            raise DMRankError("Matrix must have full row rank for Flint LLL.")
+
+        # Actually call the flint method.
+        return self.rep.lll(transform=transform, delta=delta, eta=eta, rep=rep, gram=gram)
+
+    @doctest_depends_on(ground_types='flint')
+    def lll(self, delta=0.75):
+        """Compute LLL-reduced basis using FLINT.
+
+        See :meth:`lll_transform` for more information.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> M.to_DM().to_dfm().lll()
+        [[2, 1, 0], [-1, 1, 3]]
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+            Higher level interface to compute LLL-reduced basis.
+        lll_transform
+            Compute LLL-reduced basis and transform matrix.
+        """
+        if self.domain != ZZ:
+            raise DMDomainError("ZZ expected, got %s" % self.domain)
+        elif self.rows > self.cols:
+            raise DMShapeError("Matrix must not have more rows than columns.")
+
+        rep = self._lll(delta=delta)
+        return self._new_rep(rep)
+
+    @doctest_depends_on(ground_types='flint')
+    def lll_transform(self, delta=0.75):
+        """Compute LLL-reduced basis and transform using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2, 3], [4, 5, 6]]).to_DM().to_dfm()
+        >>> M_lll, T = M.lll_transform()
+        >>> M_lll
+        [[2, 1, 0], [-1, 1, 3]]
+        >>> T
+        [[-2, 1], [3, -1]]
+        >>> T.matmul(M) == M_lll
+        True
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+            Higher level interface to compute LLL-reduced basis.
+        lll
+            Compute LLL-reduced basis without transform matrix.
+        """
+        if self.domain != ZZ:
+            raise DMDomainError("ZZ expected, got %s" % self.domain)
+        elif self.rows > self.cols:
+            raise DMShapeError("Matrix must not have more rows than columns.")
+
+        rep, T = self._lll(transform=True, delta=delta)
+        basis = self._new_rep(rep)
+        T_dfm = self._new(T, (self.rows, self.rows), self.domain)
+        return basis, T_dfm
+
+
+# Avoid circular imports
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.ddm import SDM

venv/lib/python3.12/site-packages/sympy/polys/matrices/_typing.py

@@ -0,0 +1,16 @@
+from typing import TypeVar, Protocol
+
+
+T = TypeVar('T')
+
+
+class RingElement(Protocol):
+    """A ring element.
+
+    Must support ``+``, ``-``, ``*``, ``**`` and ``-``.
+    """
+    def __add__(self: T, other: T, /) -> T: ...
+    def __sub__(self: T, other: T, /) -> T: ...
+    def __mul__(self: T, other: T, /) -> T: ...
+    def __pow__(self: T, other: int, /) -> T: ...
+    def __neg__(self: T, /) -> T: ...

venv/lib/python3.12/site-packages/sympy/polys/matrices/dense.py

@@ -0,0 +1,824 @@
+"""
+
+Module for the ddm_* routines for operating on a matrix in list of lists
+matrix representation.
+
+These routines are used internally by the DDM class which also provides a
+friendlier interface for them. The idea here is to implement core matrix
+routines in a way that can be applied to any simple list representation
+without the need to use any particular matrix class. For example we can
+compute the RREF of a matrix like:
+
+    >>> from sympy.polys.matrices.dense import ddm_irref
+    >>> M = [[1, 2, 3], [4, 5, 6]]
+    >>> pivots = ddm_irref(M)
+    >>> M
+    [[1.0, 0.0, -1.0], [0, 1.0, 2.0]]
+
+These are lower-level routines that work mostly in place.The routines at this
+level should not need to know what the domain of the elements is but should
+ideally document what operations they will use and what functions they need to
+be provided with.
+
+The next-level up is the DDM class which uses these routines but wraps them up
+with an interface that handles copying etc and keeps track of the Domain of
+the elements of the matrix:
+
+    >>> from sympy.polys.domains import QQ
+    >>> from sympy.polys.matrices.ddm import DDM
+    >>> M = DDM([[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]], (2, 3), QQ)
+    >>> M
+    [[1, 2, 3], [4, 5, 6]]
+    >>> Mrref, pivots = M.rref()
+    >>> Mrref
+    [[1, 0, -1], [0, 1, 2]]
+
+"""
+from __future__ import annotations
+from operator import mul
+from .exceptions import (
+    DMShapeError,
+    DMDomainError,
+    DMNonInvertibleMatrixError,
+    DMNonSquareMatrixError,
+)
+from typing import Sequence, TypeVar
+from sympy.polys.matrices._typing import RingElement
+
+
+#: Type variable for the elements of the matrix
+T = TypeVar('T')
+
+#: Type variable for the elements of the matrix that are in a ring
+R = TypeVar('R', bound=RingElement)
+
+
+def ddm_transpose(matrix: Sequence[Sequence[T]]) -> list[list[T]]:
+    """matrix transpose"""
+    return list(map(list, zip(*matrix)))
+
+
+def ddm_iadd(a: list[list[R]], b: Sequence[Sequence[R]]) -> None:
+    """a += b"""
+    for ai, bi in zip(a, b):
+        for j, bij in enumerate(bi):
+            ai[j] += bij
+
+
+def ddm_isub(a: list[list[R]], b: Sequence[Sequence[R]]) -> None:
+    """a -= b"""
+    for ai, bi in zip(a, b):
+        for j, bij in enumerate(bi):
+            ai[j] -= bij
+
+
+def ddm_ineg(a: list[list[R]]) -> None:
+    """a <-- -a"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = -aij
+
+
+def ddm_imul(a: list[list[R]], b: R) -> None:
+    """a <-- a*b"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = aij * b
+
+
+def ddm_irmul(a: list[list[R]], b: R) -> None:
+    """a <-- b*a"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = b * aij
+
+
+def ddm_imatmul(
+    a: list[list[R]], b: Sequence[Sequence[R]], c: Sequence[Sequence[R]]
+) -> None:
+    """a += b @ c"""
+    cT = list(zip(*c))
+
+    for bi, ai in zip(b, a):
+        for j, cTj in enumerate(cT):
+            ai[j] = sum(map(mul, bi, cTj), ai[j])
+
+
+def ddm_irref(a, _partial_pivot=False):
+    """In-place reduced row echelon form of a matrix.
+
+    Compute the reduced row echelon form of $a$. Modifies $a$ in place and
+    returns a list of the pivot columns.
+
+    Uses naive Gauss-Jordan elimination in the ground domain which must be a
+    field.
+
+    This routine is only really suitable for use with simple field domains like
+    :ref:`GF(p)`, :ref:`QQ` and :ref:`QQ(a)` although even for :ref:`QQ` with
+    larger matrices it is possibly more efficient to use fraction free
+    approaches.
+
+    This method is not suitable for use with rational function fields
+    (:ref:`K(x)`) because the elements will blowup leading to costly gcd
+    operations. In this case clearing denominators and using fraction free
+    approaches is likely to be more efficient.
+
+    For inexact numeric domains like :ref:`RR` and :ref:`CC` pass
+    ``_partial_pivot=True`` to use partial pivoting to control rounding errors.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.dense import ddm_irref
+    >>> from sympy import QQ
+    >>> M = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
+    >>> pivots = ddm_irref(M)
+    >>> M
+    [[1, 0, -1], [0, 1, 2]]
+    >>> pivots
+    [0, 1]
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref
+        Higher level interface to this routine.
+    ddm_irref_den
+        The fraction free version of this routine.
+    sdm_irref
+        A sparse version of this routine.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Row_echelon_form#Reduced_row_echelon_form
+    """
+    # We compute aij**-1 below and then use multiplication instead of division
+    # in the innermost loop. The domain here is a field so either operation is
+    # defined. There are significant performance differences for some domains
+    # though. In the case of e.g. QQ or QQ(x) inversion is free but
+    # multiplication and division have the same cost so it makes no difference.
+    # In cases like GF(p), QQ<sqrt(2)>, RR or CC though multiplication is
+    # faster than division so reusing a precomputed inverse for many
+    # multiplications can be a lot faster. The biggest win is QQ<a> when
+    # deg(minpoly(a)) is large.
+    #
+    # With domains like QQ(x) this can perform badly for other reasons.
+    # Typically the initial matrix has simple denominators and the
+    # fraction-free approach with exquo (ddm_irref_den) will preserve that
+    # property throughout. The method here causes denominator blowup leading to
+    # expensive gcd reductions in the intermediate expressions. With many
+    # generators like QQ(x,y,z,...) this is extremely bad.
+    #
+    # TODO: Use a nontrivial pivoting strategy to control intermediate
+    # expression growth. Rearranging rows and/or columns could defer the most
+    # complicated elements until the end. If the first pivot is a
+    # complicated/large element then the first round of reduction will
+    # immediately introduce expression blowup across the whole matrix.
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return []
+    n = len(a[0])
+
+    i = 0
+    pivots = []
+
+    for j in range(n):
+        # Proper pivoting should be used for all domains for performance
+        # reasons but it is only strictly needed for RR and CC (and possibly
+        # other domains like RR(x)). This path is used by DDM.rref() if the
+        # domain is RR or CC. It uses partial (row) pivoting based on the
+        # absolute value of the pivot candidates.
+        if _partial_pivot:
+            ip = max(range(i, m), key=lambda ip: abs(a[ip][j]))
+            a[i], a[ip] = a[ip], a[i]
+
+        # pivot
+        aij = a[i][j]
+
+        # zero-pivot
+        if not aij:
+            for ip in range(i+1, m):
+                aij = a[ip][j]
+                # row-swap
+                if aij:
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # next column
+                continue
+
+        # normalise row
+        ai = a[i]
+        aijinv = aij**-1
+        for l in range(j, n):
+            ai[l] *= aijinv # ai[j] = one
+
+        # eliminate above and below to the right
+        for k, ak in enumerate(a):
+            if k == i or not ak[j]:
+                continue
+            akj = ak[j]
+            ak[j] -= akj # ak[j] = zero
+            for l in range(j+1, n):
+                ak[l] -= akj * ai[l]
+
+        # next row
+        pivots.append(j)
+        i += 1
+
+        # no more rows?
+        if i >= m:
+            break
+
+    return pivots
+
+
+def ddm_irref_den(a, K):
+    """a  <--  rref(a); return (den, pivots)
+
+    Compute the fraction-free reduced row echelon form (RREF) of $a$. Modifies
+    $a$ in place and returns a tuple containing the denominator of the RREF and
+    a list of the pivot columns.
+
+    Explanation
+    ===========
+
+    The algorithm used is the fraction-free version of Gauss-Jordan elimination
+    described as FFGJ in [1]_. Here it is modified to handle zero or missing
+    pivots and to avoid redundant arithmetic.
+
+    The domain $K$ must support exact division (``K.exquo``) but does not need
+    to be a field. This method is suitable for most exact rings and fields like
+    :ref:`ZZ`, :ref:`QQ` and :ref:`QQ(a)`. In the case of :ref:`QQ` or
+    :ref:`K(x)` it might be more efficient to clear denominators and use
+    :ref:`ZZ` or :ref:`K[x]` instead.
+
+    For inexact domains like :ref:`RR` and :ref:`CC` use ``ddm_irref`` instead.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.dense import ddm_irref_den
+    >>> from sympy import ZZ, Matrix
+    >>> M = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)]]
+    >>> den, pivots = ddm_irref_den(M, ZZ)
+    >>> M
+    [[-3, 0, 3], [0, -3, -6]]
+    >>> den
+    -3
+    >>> pivots
+    [0, 1]
+    >>> Matrix(M).rref()[0]
+    Matrix([
+    [1, 0, -1],
+    [0, 1,  2]])
+
+    See Also
+    ========
+
+    ddm_irref
+        A version of this routine that uses field division.
+    sdm_irref
+        A sparse version of :func:`ddm_irref`.
+    sdm_rref_den
+        A sparse version of :func:`ddm_irref_den`.
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den
+        Higher level interface.
+
+    References
+    ==========
+
+    .. [1] Fraction-free algorithms for linear and polynomial equations.
+        George C. Nakos , Peter R. Turner , Robert M. Williams.
+        https://dl.acm.org/doi/10.1145/271130.271133
+    """
+    #
+    # A simpler presentation of this algorithm is given in [1]:
+    #
+    # Given an n x n matrix A and n x 1 matrix b:
+    #
+    #   for i in range(n):
+    #       if i != 0:
+    #           d = a[i-1][i-1]
+    #       for j in range(n):
+    #           if j == i:
+    #               continue
+    #           b[j] = a[i][i]*b[j] - a[j][i]*b[i]
+    #           for k in range(n):
+    #               a[j][k] = a[i][i]*a[j][k] - a[j][i]*a[i][k]
+    #               if i != 0:
+    #                   a[j][k] /= d
+    #
+    # Our version here is a bit more complicated because:
+    #
+    #  1. We use row-swaps to avoid zero pivots.
+    #  2. We allow for some columns to be missing pivots.
+    #  3. We avoid a lot of redundant arithmetic.
+    #
+    # TODO: Use a non-trivial pivoting strategy. Even just row swapping makes a
+    # big difference to performance if e.g. the upper-left entry of the matrix
+    # is a huge polynomial.
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return K.one, []
+    n = len(a[0])
+
+    d = None
+    pivots = []
+    no_pivots = []
+
+    # i, j will be the row and column indices of the current pivot
+    i = 0
+    for j in range(n):
+        # next pivot?
+        aij = a[i][j]
+
+        # swap rows if zero
+        if not aij:
+            for ip in range(i+1, m):
+                aij = a[ip][j]
+                # row-swap
+                if aij:
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # go to next column
+                no_pivots.append(j)
+                continue
+
+        # Now aij is the pivot and i,j are the row and column. We need to clear
+        # the column above and below but we also need to keep track of the
+        # denominator of the RREF which means also multiplying everything above
+        # and to the left by the current pivot aij and dividing by d (which we
+        # multiplied everything by in the previous iteration so this is an
+        # exact division).
+        #
+        # First handle the upper left corner which is usually already diagonal
+        # with all diagonal entries equal to the current denominator but there
+        # can be other non-zero entries in any column that has no pivot.
+
+        # Update previous pivots in the matrix
+        if pivots:
+            pivot_val = aij * a[0][pivots[0]]
+            # Divide out the common factor
+            if d is not None:
+                pivot_val = K.exquo(pivot_val, d)
+
+            # Could defer this until the end but it is pretty cheap and
+            # helps when debugging.
+            for ip, jp in enumerate(pivots):
+                a[ip][jp] = pivot_val
+
+        # Update columns without pivots
+        for jnp in no_pivots:
+            for ip in range(i):
+                aijp = a[ip][jnp]
+                if aijp:
+                    aijp *= aij
+                    if d is not None:
+                        aijp = K.exquo(aijp, d)
+                    a[ip][jnp] = aijp
+
+        # Eliminate above, below and to the right as in ordinary division free
+        # Gauss-Jordan elmination except also dividing out d from every entry.
+
+        for jp, aj in enumerate(a):
+
+            # Skip the current row
+            if jp == i:
+                continue
+
+            # Eliminate to the right in all rows
+            for kp in range(j+1, n):
+                ajk = aij * aj[kp] - aj[j] * a[i][kp]
+                if d is not None:
+                    ajk = K.exquo(ajk, d)
+                aj[kp] = ajk
+
+            # Set to zero above and below the pivot
+            aj[j] = K.zero
+
+        # next row
+        pivots.append(j)
+        i += 1
+
+        # no more rows left?
+        if i >= m:
+            break
+
+        if not K.is_one(aij):
+            d = aij
+        else:
+            d = None
+
+    if not pivots:
+        denom = K.one
+    else:
+        denom = a[0][pivots[0]]
+
+    return denom, pivots
+
+
+def ddm_idet(a, K):
+    """a  <--  echelon(a); return det
+
+    Explanation
+    ===========
+
+    Compute the determinant of $a$ using the Bareiss fraction-free algorithm.
+    The matrix $a$ is modified in place. Its diagonal elements are the
+    determinants of the leading principal minors. The determinant of $a$ is
+    returned.
+
+    The domain $K$ must support exact division (``K.exquo``). This method is
+    suitable for most exact rings and fields like :ref:`ZZ`, :ref:`QQ` and
+    :ref:`QQ(a)` but not for inexact domains like :ref:`RR` and :ref:`CC`.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices.ddm import ddm_idet
+    >>> a = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]]
+    >>> a
+    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    >>> ddm_idet(a, ZZ)
+    0
+    >>> a
+    [[1, 2, 3], [4, -3, -6], [7, -6, 0]]
+    >>> [a[i][i] for i in range(len(a))]
+    [1, -3, 0]
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.det
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bareiss_algorithm
+    .. [2] https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf
+    """
+    # Bareiss algorithm
+    # https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return K.one
+    n = len(a[0])
+
+    exquo = K.exquo
+    # uf keeps track of the sign change from row swaps
+    uf = K.one
+
+    for k in range(n-1):
+        if not a[k][k]:
+            for i in range(k+1, n):
+                if a[i][k]:
+                    a[k], a[i] = a[i], a[k]
+                    uf = -uf
+                    break
+            else:
+                return K.zero
+
+        akkm1 = a[k-1][k-1] if k else K.one
+
+        for i in range(k+1, n):
+            for j in range(k+1, n):
+                a[i][j] = exquo(a[i][j]*a[k][k] - a[i][k]*a[k][j], akkm1)
+
+    return uf * a[-1][-1]
+
+
+def ddm_iinv(ainv, a, K):
+    """ainv  <--  inv(a)
+
+    Compute the inverse of a matrix $a$ over a field $K$ using Gauss-Jordan
+    elimination. The result is stored in $ainv$.
+
+    Uses division in the ground domain which should be an exact field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.ddm import ddm_iinv, ddm_imatmul
+    >>> from sympy import QQ
+    >>> a = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    >>> ainv = [[None, None], [None, None]]
+    >>> ddm_iinv(ainv, a, QQ)
+    >>> ainv
+    [[-2, 1], [3/2, -1/2]]
+    >>> result = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    >>> ddm_imatmul(result, a, ainv)
+    >>> result
+    [[1, 0], [0, 1]]
+
+    See Also
+    ========
+
+    ddm_irref: the underlying routine.
+    """
+    if not K.is_Field:
+        raise DMDomainError('Not a field')
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return
+    n = len(a[0])
+    if m != n:
+        raise DMNonSquareMatrixError
+
+    eye = [[K.one if i==j else K.zero for j in range(n)] for i in range(n)]
+    Aaug = [row + eyerow for row, eyerow in zip(a, eye)]
+    pivots = ddm_irref(Aaug)
+    if pivots != list(range(n)):
+        raise DMNonInvertibleMatrixError('Matrix det == 0; not invertible.')
+    ainv[:] = [row[n:] for row in Aaug]
+
+
+def ddm_ilu_split(L, U, K):
+    """L, U  <--  LU(U)
+
+    Compute the LU decomposition of a matrix $L$ in place and store the lower
+    and upper triangular matrices in $L$ and $U$, respectively. Returns a list
+    of row swaps that were performed.
+
+    Uses division in the ground domain which should be an exact field.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.ddm import ddm_ilu_split
+    >>> from sympy import QQ
+    >>> L = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    >>> U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    >>> swaps = ddm_ilu_split(L, U, QQ)
+    >>> swaps
+    []
+    >>> L
+    [[0, 0], [3, 0]]
+    >>> U
+    [[1, 2], [0, -2]]
+
+    See Also
+    ========
+
+    ddm_ilu
+    ddm_ilu_solve
+    """
+    m = len(U)
+    if not m:
+        return []
+    n = len(U[0])
+
+    swaps = ddm_ilu(U)
+
+    zeros = [K.zero] * min(m, n)
+    for i in range(1, m):
+        j = min(i, n)
+        L[i][:j] = U[i][:j]
+        U[i][:j] = zeros[:j]
+
+    return swaps
+
+
+def ddm_ilu(a):
+    """a  <--  LU(a)
+
+    Computes the LU decomposition of a matrix in place. Returns a list of
+    row swaps that were performed.
+
+    Uses division in the ground domain which should be an exact field.
+
+    This is only suitable for domains like :ref:`GF(p)`, :ref:`QQ`, :ref:`QQ_I`
+    and :ref:`QQ(a)`. With a rational function field like :ref:`K(x)` it is
+    better to clear denominators and use division-free algorithms. Pivoting is
+    used to avoid exact zeros but not for floating point accuracy so :ref:`RR`
+    and :ref:`CC` are not suitable (use :func:`ddm_irref` instead).
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.dense import ddm_ilu
+    >>> from sympy import QQ
+    >>> a = [[QQ(1, 2), QQ(1, 3)], [QQ(1, 4), QQ(1, 5)]]
+    >>> swaps = ddm_ilu(a)
+    >>> swaps
+    []
+    >>> a
+    [[1/2, 1/3], [1/2, 1/30]]
+
+    The same example using ``Matrix``:
+
+    >>> from sympy import Matrix, S
+    >>> M = Matrix([[S(1)/2, S(1)/3], [S(1)/4, S(1)/5]])
+    >>> L, U, swaps = M.LUdecomposition()
+    >>> L
+    Matrix([
+    [  1, 0],
+    [1/2, 1]])
+    >>> U
+    Matrix([
+    [1/2,  1/3],
+    [  0, 1/30]])
+    >>> swaps
+    []
+
+    See Also
+    ========
+
+    ddm_irref
+    ddm_ilu_solve
+    sympy.matrices.matrixbase.MatrixBase.LUdecomposition
+    """
+    m = len(a)
+    if not m:
+        return []
+    n = len(a[0])
+
+    swaps = []
+
+    for i in range(min(m, n)):
+        if not a[i][i]:
+            for ip in range(i+1, m):
+                if a[ip][i]:
+                    swaps.append((i, ip))
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # M = Matrix([[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 1, 2]])
+                continue
+        for j in range(i+1, m):
+            l_ji = a[j][i] / a[i][i]
+            a[j][i] = l_ji
+            for k in range(i+1, n):
+                a[j][k] -= l_ji * a[i][k]
+
+    return swaps
+
+
+def ddm_ilu_solve(x, L, U, swaps, b):
+    """x  <--  solve(L*U*x = swaps(b))
+
+    Solve a linear system, $A*x = b$, given an LU factorization of $A$.
+
+    Uses division in the ground domain which must be a field.
+
+    Modifies $x$ in place.
+
+    Examples
+    ========
+
+    Compute the LU decomposition of $A$ (in place):
+
+    >>> from sympy import QQ
+    >>> from sympy.polys.matrices.dense import ddm_ilu, ddm_ilu_solve
+    >>> A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    >>> swaps = ddm_ilu(A)
+    >>> A
+    [[1, 2], [3, -2]]
+    >>> L = U = A
+
+    Solve the linear system:
+
+    >>> b = [[QQ(5)], [QQ(6)]]
+    >>> x = [[None], [None]]
+    >>> ddm_ilu_solve(x, L, U, swaps, b)
+    >>> x
+    [[-4], [9/2]]
+
+    See Also
+    ========
+
+    ddm_ilu
+        Compute the LU decomposition of a matrix in place.
+    ddm_ilu_split
+        Compute the LU decomposition of a matrix and separate $L$ and $U$.
+    sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve
+        Higher level interface to this function.
+    """
+    m = len(U)
+    if not m:
+        return
+    n = len(U[0])
+
+    m2 = len(b)
+    if not m2:
+        raise DMShapeError("Shape mismtch")
+    o = len(b[0])
+
+    if m != m2:
+        raise DMShapeError("Shape mismtch")
+    if m < n:
+        raise NotImplementedError("Underdetermined")
+
+    if swaps:
+        b = [row[:] for row in b]
+        for i1, i2 in swaps:
+            b[i1], b[i2] = b[i2], b[i1]
+
+    # solve Ly = b
+    y = [[None] * o for _ in range(m)]
+    for k in range(o):
+        for i in range(m):
+            rhs = b[i][k]
+            for j in range(i):
+                rhs -= L[i][j] * y[j][k]
+            y[i][k] = rhs
+
+    if m > n:
+        for i in range(n, m):
+            for j in range(o):
+                if y[i][j]:
+                    raise DMNonInvertibleMatrixError
+
+    # Solve Ux = y
+    for k in range(o):
+        for i in reversed(range(n)):
+            if not U[i][i]:
+                raise DMNonInvertibleMatrixError
+            rhs = y[i][k]
+            for j in range(i+1, n):
+                rhs -= U[i][j] * x[j][k]
+            x[i][k] = rhs / U[i][i]
+
+
+def ddm_berk(M, K):
+    """
+    Berkowitz algorithm for computing the characteristic polynomial.
+
+    Explanation
+    ===========
+
+    The Berkowitz algorithm is a division-free algorithm for computing the
+    characteristic polynomial of a matrix over any commutative ring using only
+    arithmetic in the coefficient ring.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> from sympy.polys.matrices.dense import ddm_berk
+    >>> from sympy.polys.domains import ZZ
+    >>> M = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    >>> ddm_berk(M, ZZ)
+    [[1], [-5], [-2]]
+    >>> Matrix(M).charpoly()
+    PurePoly(lambda**2 - 5*lambda - 2, lambda, domain='ZZ')
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly
+        The high-level interface to this function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Samuelson%E2%80%93Berkowitz_algorithm
+    """
+    m = len(M)
+    if not m:
+        return [[K.one]]
+    n = len(M[0])
+
+    if m != n:
+        raise DMShapeError("Not square")
+
+    if n == 1:
+        return [[K.one], [-M[0][0]]]
+
+    a = M[0][0]
+    R = [M[0][1:]]
+    C = [[row[0]] for row in M[1:]]
+    A = [row[1:] for row in M[1:]]
+
+    q = ddm_berk(A, K)
+
+    T = [[K.zero] * n for _ in range(n+1)]
+    for i in range(n):
+        T[i][i] = K.one
+        T[i+1][i] = -a
+    for i in range(2, n+1):
+        if i == 2:
+            AnC = C
+        else:
+            C = AnC
+            AnC = [[K.zero] for row in C]
+            ddm_imatmul(AnC, A, C)
+        RAnC = [[K.zero]]
+        ddm_imatmul(RAnC, R, AnC)
+        for j in range(0, n+1-i):
+            T[i+j][j] = -RAnC[0][0]
+
+    qout = [[K.zero] for _ in range(n+1)]
+    ddm_imatmul(qout, T, q)
+    return qout

venv/lib/python3.12/site-packages/sympy/polys/matrices/dfm.py

@@ -0,0 +1,35 @@
+"""
+sympy.polys.matrices.dfm
+
+Provides the :class:`DFM` class if ``GROUND_TYPES=flint'``. Otherwise, ``DFM``
+is a placeholder class that raises NotImplementedError when instantiated.
+"""
+
+from sympy.external.gmpy import GROUND_TYPES
+
+if GROUND_TYPES == "flint":  # pragma: no cover
+    # When python-flint is installed we will try to use it for dense matrices
+    # if the domain is supported by python-flint.
+    from ._dfm import DFM
+
+else: # pragma: no cover
+    # Other code should be able to import this and it should just present as a
+    # version of DFM that does not support any domains.
+    class DFM_dummy:
+        """
+        Placeholder class for DFM when python-flint is not installed.
+        """
+        def __init__(*args, **kwargs):
+            raise NotImplementedError("DFM requires GROUND_TYPES=flint.")
+
+        @classmethod
+        def _supports_domain(cls, domain):
+            return False
+
+        @classmethod
+        def _get_flint_func(cls, domain):
+            raise NotImplementedError("DFM requires GROUND_TYPES=flint.")
+
+    # mypy really struggles with this kind of conditional type assignment.
+    # Maybe there is a better way to annotate this rather than type: ignore.
+    DFM = DFM_dummy # type: ignore

venv/lib/python3.12/site-packages/sympy/polys/matrices/domainscalar.py

@@ -0,0 +1,122 @@
+"""
+
+Module for the DomainScalar class.
+
+A DomainScalar represents an element which is in a particular
+Domain. The idea is that the DomainScalar class provides the
+convenience routines for unifying elements with different domains.
+
+It assists in Scalar Multiplication and getitem for DomainMatrix.
+
+"""
+from ..constructor import construct_domain
+
+from sympy.polys.domains import Domain, ZZ
+
+
+class DomainScalar:
+    r"""
+    docstring
+    """
+
+    def __new__(cls, element, domain):
+        if not isinstance(domain, Domain):
+            raise TypeError("domain should be of type Domain")
+        if not domain.of_type(element):
+            raise TypeError("element %s should be in domain %s" % (element, domain))
+        return cls.new(element, domain)
+
+    @classmethod
+    def new(cls, element, domain):
+        obj = super().__new__(cls)
+        obj.element = element
+        obj.domain = domain
+        return obj
+
+    def __repr__(self):
+        return repr(self.element)
+
+    @classmethod
+    def from_sympy(cls, expr):
+        [domain, [element]] = construct_domain([expr])
+        return cls.new(element, domain)
+
+    def to_sympy(self):
+        return self.domain.to_sympy(self.element)
+
+    def to_domain(self, domain):
+        element = domain.convert_from(self.element, self.domain)
+        return self.new(element, domain)
+
+    def convert_to(self, domain):
+        return self.to_domain(domain)
+
+    def unify(self, other):
+        domain = self.domain.unify(other.domain)
+        return self.to_domain(domain), other.to_domain(domain)
+
+    def __bool__(self):
+        return bool(self.element)
+
+    def __add__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.element + other.element, self.domain)
+
+    def __sub__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.element - other.element, self.domain)
+
+    def __mul__(self, other):
+        if not isinstance(other, DomainScalar):
+            if isinstance(other, int):
+                other = DomainScalar(ZZ(other), ZZ)
+            else:
+                return NotImplemented
+
+        self, other = self.unify(other)
+        return self.new(self.element * other.element, self.domain)
+
+    def __floordiv__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.domain.quo(self.element, other.element), self.domain)
+
+    def __mod__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.domain.rem(self.element, other.element), self.domain)
+
+    def __divmod__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        q, r = self.domain.div(self.element, other.element)
+        return (self.new(q, self.domain), self.new(r, self.domain))
+
+    def __pow__(self, n):
+        if not isinstance(n, int):
+            return NotImplemented
+        return self.new(self.element**n, self.domain)
+
+    def __pos__(self):
+        return self.new(+self.element, self.domain)
+
+    def __neg__(self):
+        return self.new(-self.element, self.domain)
+
+    def __eq__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        return self.element == other.element and self.domain == other.domain
+
+    def is_zero(self):
+        return self.element == self.domain.zero
+
+    def is_one(self):
+        return self.element == self.domain.one

venv/lib/python3.12/site-packages/sympy/polys/matrices/eigen.py

@@ -0,0 +1,90 @@
+"""
+
+Routines for computing eigenvectors with DomainMatrix.
+
+"""
+from sympy.core.symbol import Dummy
+
+from ..agca.extensions import FiniteExtension
+from ..factortools import dup_factor_list
+from ..polyroots import roots
+from ..polytools import Poly
+from ..rootoftools import CRootOf
+
+from .domainmatrix import DomainMatrix
+
+
+def dom_eigenvects(A, l=Dummy('lambda')):
+    charpoly = A.charpoly()
+    rows, cols = A.shape
+    domain = A.domain
+    _, factors = dup_factor_list(charpoly, domain)
+
+    rational_eigenvects = []
+    algebraic_eigenvects = []
+    for base, exp in factors:
+        if len(base) == 2:
+            field = domain
+            eigenval = -base[1] / base[0]
+
+            EE_items = [
+                [eigenval if i == j else field.zero for j in range(cols)]
+                for i in range(rows)]
+            EE = DomainMatrix(EE_items, (rows, cols), field)
+
+            basis = (A - EE).nullspace(divide_last=True)
+            rational_eigenvects.append((field, eigenval, exp, basis))
+        else:
+            minpoly = Poly.from_list(base, l, domain=domain)
+            field = FiniteExtension(minpoly)
+            eigenval = field(l)
+
+            AA_items = [
+                [Poly.from_list([item], l, domain=domain).rep for item in row]
+                for row in A.rep.to_ddm()]
+            AA_items = [[field(item) for item in row] for row in AA_items]
+            AA = DomainMatrix(AA_items, (rows, cols), field)
+            EE_items = [
+                [eigenval if i == j else field.zero for j in range(cols)]
+                for i in range(rows)]
+            EE = DomainMatrix(EE_items, (rows, cols), field)
+
+            basis = (AA - EE).nullspace(divide_last=True)
+            algebraic_eigenvects.append((field, minpoly, exp, basis))
+
+    return rational_eigenvects, algebraic_eigenvects
+
+
+def dom_eigenvects_to_sympy(
+    rational_eigenvects, algebraic_eigenvects,
+    Matrix, **kwargs
+):
+    result = []
+
+    for field, eigenvalue, multiplicity, eigenvects in rational_eigenvects:
+        eigenvects = eigenvects.rep.to_ddm()
+        eigenvalue = field.to_sympy(eigenvalue)
+        new_eigenvects = [
+            Matrix([field.to_sympy(x) for x in vect])
+            for vect in eigenvects]
+        result.append((eigenvalue, multiplicity, new_eigenvects))
+
+    for field, minpoly, multiplicity, eigenvects in algebraic_eigenvects:
+        eigenvects = eigenvects.rep.to_ddm()
+        l = minpoly.gens[0]
+
+        eigenvects = [[field.to_sympy(x) for x in vect] for vect in eigenvects]
+
+        degree = minpoly.degree()
+        minpoly = minpoly.as_expr()
+        eigenvals = roots(minpoly, l, **kwargs)
+        if len(eigenvals) != degree:
+            eigenvals = [CRootOf(minpoly, l, idx) for idx in range(degree)]
+
+        for eigenvalue in eigenvals:
+            new_eigenvects = [
+                Matrix([x.subs(l, eigenvalue) for x in vect])
+                for vect in eigenvects]
+            result.append((eigenvalue, multiplicity, new_eigenvects))
+
+    return result

venv/lib/python3.12/site-packages/sympy/polys/matrices/exceptions.py

@@ -0,0 +1,67 @@
+"""
+
+Module to define exceptions to be used in sympy.polys.matrices modules and
+classes.
+
+Ideally all exceptions raised in these modules would be defined and documented
+here and not e.g. imported from matrices. Also ideally generic exceptions like
+ValueError/TypeError would not be raised anywhere.
+
+"""
+
+
+class DMError(Exception):
+    """Base class for errors raised by DomainMatrix"""
+    pass
+
+
+class DMBadInputError(DMError):
+    """list of lists is inconsistent with shape"""
+    pass
+
+
+class DMDomainError(DMError):
+    """domains do not match"""
+    pass
+
+
+class DMNotAField(DMDomainError):
+    """domain is not a field"""
+    pass
+
+
+class DMFormatError(DMError):
+    """mixed dense/sparse not supported"""
+    pass
+
+
+class DMNonInvertibleMatrixError(DMError):
+    """The matrix in not invertible"""
+    pass
+
+
+class DMRankError(DMError):
+    """matrix does not have expected rank"""
+    pass
+
+
+class DMShapeError(DMError):
+    """shapes are inconsistent"""
+    pass
+
+
+class DMNonSquareMatrixError(DMShapeError):
+    """The matrix is not square"""
+    pass
+
+
+class DMValueError(DMError):
+    """The value passed is invalid"""
+    pass
+
+
+__all__ = [
+    'DMError', 'DMBadInputError', 'DMDomainError', 'DMFormatError',
+    'DMRankError', 'DMShapeError', 'DMNotAField',
+    'DMNonInvertibleMatrixError', 'DMNonSquareMatrixError', 'DMValueError'
+]

venv/lib/python3.12/site-packages/sympy/polys/matrices/linsolve.py

@@ -0,0 +1,230 @@
+#
+# sympy.polys.matrices.linsolve module
+#
+# This module defines the _linsolve function which is the internal workhorse
+# used by linsolve. This computes the solution of a system of linear equations
+# using the SDM sparse matrix implementation in sympy.polys.matrices.sdm. This
+# is a replacement for solve_lin_sys in sympy.polys.solvers which is
+# inefficient for large sparse systems due to the use of a PolyRing with many
+# generators:
+#
+#     https://github.com/sympy/sympy/issues/20857
+#
+# The implementation of _linsolve here handles:
+#
+# - Extracting the coefficients from the Expr/Eq input equations.
+# - Constructing a domain and converting the coefficients to
+#   that domain.
+# - Using the SDM.rref, SDM.nullspace etc methods to generate the full
+#   solution working with arithmetic only in the domain of the coefficients.
+#
+# The routines here are particularly designed to be efficient for large sparse
+# systems of linear equations although as well as dense systems. It is
+# possible that for some small dense systems solve_lin_sys which uses the
+# dense matrix implementation DDM will be more efficient. With smaller systems
+# though the bulk of the time is spent just preprocessing the inputs and the
+# relative time spent in rref is too small to be noticeable.
+#
+
+from collections import defaultdict
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+
+from sympy.polys.constructor import construct_domain
+from sympy.polys.solvers import PolyNonlinearError
+
+from .sdm import (
+    SDM,
+    sdm_irref,
+    sdm_particular_from_rref,
+    sdm_nullspace_from_rref
+)
+
+from sympy.utilities.misc import filldedent
+
+
+def _linsolve(eqs, syms):
+
+    """Solve a linear system of equations.
+
+    Examples
+    ========
+
+    Solve a linear system with a unique solution:
+
+    >>> from sympy import symbols, Eq
+    >>> from sympy.polys.matrices.linsolve import _linsolve
+    >>> x, y = symbols('x, y')
+    >>> eqs = [Eq(x + y, 1), Eq(x - y, 2)]
+    >>> _linsolve(eqs, [x, y])
+    {x: 3/2, y: -1/2}
+
+    In the case of underdetermined systems the solution will be expressed in
+    terms of the unknown symbols that are unconstrained:
+
+    >>> _linsolve([Eq(x + y, 0)], [x, y])
+    {x: -y, y: y}
+
+    """
+    # Number of unknowns (columns in the non-augmented matrix)
+    nsyms = len(syms)
+
+    # Convert to sparse augmented matrix (len(eqs) x (nsyms+1))
+    eqsdict, const = _linear_eq_to_dict(eqs, syms)
+    Aaug = sympy_dict_to_dm(eqsdict, const, syms)
+    K = Aaug.domain
+
+    # sdm_irref has issues with float matrices. This uses the ddm_rref()
+    # function. When sdm_rref() can handle float matrices reasonably this
+    # should be removed...
+    if K.is_RealField or K.is_ComplexField:
+        Aaug = Aaug.to_ddm().rref()[0].to_sdm()
+
+    # Compute reduced-row echelon form (RREF)
+    Arref, pivots, nzcols = sdm_irref(Aaug)
+
+    # No solution:
+    if pivots and pivots[-1] == nsyms:
+        return None
+
+    # Particular solution for non-homogeneous system:
+    P = sdm_particular_from_rref(Arref, nsyms+1, pivots)
+
+    # Nullspace - general solution to homogeneous system
+    # Note: using nsyms not nsyms+1 to ignore last column
+    V, nonpivots = sdm_nullspace_from_rref(Arref, K.one, nsyms, pivots, nzcols)
+
+    # Collect together terms from particular and nullspace:
+    sol = defaultdict(list)
+    for i, v in P.items():
+        sol[syms[i]].append(K.to_sympy(v))
+    for npi, Vi in zip(nonpivots, V):
+        sym = syms[npi]
+        for i, v in Vi.items():
+            sol[syms[i]].append(sym * K.to_sympy(v))
+
+    # Use a single call to Add for each term:
+    sol = {s: Add(*terms) for s, terms in sol.items()}
+
+    # Fill in the zeros:
+    zero = S.Zero
+    for s in set(syms) - set(sol):
+        sol[s] = zero
+
+    # All done!
+    return sol
+
+
+def sympy_dict_to_dm(eqs_coeffs, eqs_rhs, syms):
+    """Convert a system of dict equations to a sparse augmented matrix"""
+    elems = set(eqs_rhs).union(*(e.values() for e in eqs_coeffs))
+    K, elems_K = construct_domain(elems, field=True, extension=True)
+    elem_map = dict(zip(elems, elems_K))
+    neqs = len(eqs_coeffs)
+    nsyms = len(syms)
+    sym2index = dict(zip(syms, range(nsyms)))
+    eqsdict = []
+    for eq, rhs in zip(eqs_coeffs, eqs_rhs):
+        eqdict = {sym2index[s]: elem_map[c] for s, c in eq.items()}
+        if rhs:
+            eqdict[nsyms] = -elem_map[rhs]
+        if eqdict:
+            eqsdict.append(eqdict)
+    sdm_aug = SDM(enumerate(eqsdict), (neqs, nsyms + 1), K)
+    return sdm_aug
+
+
+def _linear_eq_to_dict(eqs, syms):
+    """Convert a system Expr/Eq equations into dict form, returning
+    the coefficient dictionaries and a list of syms-independent terms
+    from each expression in ``eqs```.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.linsolve import _linear_eq_to_dict
+    >>> from sympy.abc import x
+    >>> _linear_eq_to_dict([2*x + 3], {x})
+    ([{x: 2}], [3])
+    """
+    coeffs = []
+    ind = []
+    symset = set(syms)
+    for e in eqs:
+        if e.is_Equality:
+            coeff, terms = _lin_eq2dict(e.lhs, symset)
+            cR, tR = _lin_eq2dict(e.rhs, symset)
+            # there were no nonlinear errors so now
+            # cancellation is allowed
+            coeff -= cR
+            for k, v in tR.items():
+                if k in terms:
+                    terms[k] -= v
+                else:
+                    terms[k] = -v
+            # don't store coefficients of 0, however
+            terms = {k: v for k, v in terms.items() if v}
+            c, d = coeff, terms
+        else:
+            c, d = _lin_eq2dict(e, symset)
+        coeffs.append(d)
+        ind.append(c)
+    return coeffs, ind
+
+
+def _lin_eq2dict(a, symset):
+    """return (c, d) where c is the sym-independent part of ``a`` and
+    ``d`` is an efficiently calculated dictionary mapping symbols to
+    their coefficients. A PolyNonlinearError is raised if non-linearity
+    is detected.
+
+    The values in the dictionary will be non-zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.linsolve import _lin_eq2dict
+    >>> from sympy.abc import x, y
+    >>> _lin_eq2dict(x + 2*y + 3, {x, y})
+    (3, {x: 1, y: 2})
+    """
+    if a in symset:
+        return S.Zero, {a: S.One}
+    elif a.is_Add:
+        terms_list = defaultdict(list)
+        coeff_list = []
+        for ai in a.args:
+            ci, ti = _lin_eq2dict(ai, symset)
+            coeff_list.append(ci)
+            for mij, cij in ti.items():
+                terms_list[mij].append(cij)
+        coeff = Add(*coeff_list)
+        terms = {sym: Add(*coeffs) for sym, coeffs in terms_list.items()}
+        return coeff, terms
+    elif a.is_Mul:
+        terms = terms_coeff = None
+        coeff_list = []
+        for ai in a.args:
+            ci, ti = _lin_eq2dict(ai, symset)
+            if not ti:
+                coeff_list.append(ci)
+            elif terms is None:
+                terms = ti
+                terms_coeff = ci
+            else:
+                # since ti is not null and we already have
+                # a term, this is a cross term
+                raise PolyNonlinearError(filldedent('''
+                    nonlinear cross-term: %s''' % a))
+        coeff = Mul._from_args(coeff_list)
+        if terms is None:
+            return coeff, {}
+        else:
+            terms = {sym: coeff * c for sym, c in terms.items()}
+            return  coeff * terms_coeff, terms
+    elif not a.has_xfree(symset):
+        return a, {}
+    else:
+        raise PolyNonlinearError('nonlinear term: %s' % a)

venv/lib/python3.12/site-packages/sympy/polys/matrices/lll.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from math import floor as mfloor
+
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices.exceptions import DMRankError, DMShapeError, DMValueError, DMDomainError
+
+
+def _ddm_lll(x, delta=QQ(3, 4), return_transform=False):
+    if QQ(1, 4) >= delta or delta >= QQ(1, 1):
+        raise DMValueError("delta must lie in range (0.25, 1)")
+    if x.shape[0] > x.shape[1]:
+        raise DMShapeError("input matrix must have shape (m, n) with m <= n")
+    if x.domain != ZZ:
+        raise DMDomainError("input matrix domain must be ZZ")
+    m = x.shape[0]
+    n = x.shape[1]
+    k = 1
+    y = x.copy()
+    y_star = x.zeros((m, n), QQ)
+    mu = x.zeros((m, m), QQ)
+    g_star = [QQ(0, 1) for _ in range(m)]
+    half = QQ(1, 2)
+    T = x.eye(m, ZZ) if return_transform else None
+    linear_dependent_error = "input matrix contains linearly dependent rows"
+
+    def closest_integer(x):
+        return ZZ(mfloor(x + half))
+
+    def lovasz_condition(k: int) -> bool:
+        return g_star[k] >= ((delta - mu[k][k - 1] ** 2) * g_star[k - 1])
+
+    def mu_small(k: int, j: int) -> bool:
+        return abs(mu[k][j]) <= half
+
+    def dot_rows(x, y, rows: tuple[int, int]):
+        return sum(x[rows[0]][z] * y[rows[1]][z] for z in range(x.shape[1]))
+
+    def reduce_row(T, mu, y, rows: tuple[int, int]):
+        r = closest_integer(mu[rows[0]][rows[1]])
+        y[rows[0]] = [y[rows[0]][z] - r * y[rows[1]][z] for z in range(n)]
+        mu[rows[0]][:rows[1]] = [mu[rows[0]][z] - r * mu[rows[1]][z] for z in range(rows[1])]
+        mu[rows[0]][rows[1]] -= r
+        if return_transform:
+            T[rows[0]] = [T[rows[0]][z] - r * T[rows[1]][z] for z in range(m)]
+
+    for i in range(m):
+        y_star[i] = [QQ.convert_from(z, ZZ) for z in y[i]]
+        for j in range(i):
+            row_dot = dot_rows(y, y_star, (i, j))
+            try:
+                mu[i][j] = row_dot / g_star[j]
+            except ZeroDivisionError:
+                raise DMRankError(linear_dependent_error)
+            y_star[i] = [y_star[i][z] - mu[i][j] * y_star[j][z] for z in range(n)]
+        g_star[i] = dot_rows(y_star, y_star, (i, i))
+    while k < m:
+        if not mu_small(k, k - 1):
+            reduce_row(T, mu, y, (k, k - 1))
+        if lovasz_condition(k):
+            for l in range(k - 2, -1, -1):
+                if not mu_small(k, l):
+                    reduce_row(T, mu, y, (k, l))
+            k += 1
+        else:
+            nu = mu[k][k - 1]
+            alpha = g_star[k] + nu ** 2 * g_star[k - 1]
+            try:
+                beta = g_star[k - 1] / alpha
+            except ZeroDivisionError:
+                raise DMRankError(linear_dependent_error)
+            mu[k][k - 1] = nu * beta
+            g_star[k] = g_star[k] * beta
+            g_star[k - 1] = alpha
+            y[k], y[k - 1] = y[k - 1], y[k]
+            mu[k][:k - 1], mu[k - 1][:k - 1] = mu[k - 1][:k - 1], mu[k][:k - 1]
+            for i in range(k + 1, m):
+                xi = mu[i][k]
+                mu[i][k] = mu[i][k - 1] - nu * xi
+                mu[i][k - 1] = mu[k][k - 1] * mu[i][k] + xi
+            if return_transform:
+                T[k], T[k - 1] = T[k - 1], T[k]
+            k = max(k - 1, 1)
+    assert all(lovasz_condition(i) for i in range(1, m))
+    assert all(mu_small(i, j) for i in range(m) for j in range(i))
+    return y, T
+
+
+def ddm_lll(x, delta=QQ(3, 4)):
+    return _ddm_lll(x, delta=delta, return_transform=False)[0]
+
+
+def ddm_lll_transform(x, delta=QQ(3, 4)):
+    return _ddm_lll(x, delta=delta, return_transform=True)

venv/lib/python3.12/site-packages/sympy/polys/matrices/normalforms.py

@@ -0,0 +1,540 @@
+'''Functions returning normal forms of matrices'''
+
+from collections import defaultdict
+
+from .domainmatrix import DomainMatrix
+from .exceptions import DMDomainError, DMShapeError
+from sympy.ntheory.modular import symmetric_residue
+from sympy.polys.domains import QQ, ZZ
+
+
+# TODO (future work):
+#  There are faster algorithms for Smith and Hermite normal forms, which
+#  we should implement. See e.g. the Kannan-Bachem algorithm:
+#  <https://www.researchgate.net/publication/220617516_Polynomial_Algorithms_for_Computing_the_Smith_and_Hermite_Normal_Forms_of_an_Integer_Matrix>
+
+
+def smith_normal_form(m):
+    '''
+    Return the Smith Normal Form of a matrix `m` over the ring `domain`.
+    This will only work if the ring is a principal ideal domain.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import smith_normal_form
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> print(smith_normal_form(m).to_Matrix())
+    Matrix([[1, 0, 0], [0, 10, 0], [0, 0, 30]])
+
+    '''
+    invs = invariant_factors(m)
+    smf = DomainMatrix.diag(invs, m.domain, m.shape)
+    return smf
+
+
+def is_smith_normal_form(m):
+    '''
+    Checks that the matrix is in Smith Normal Form
+    '''
+    domain = m.domain
+    shape = m.shape
+    zero = domain.zero
+    m = m.to_list()
+
+    for i in range(shape[0]):
+        for j in range(shape[1]):
+            if i == j:
+                continue
+            if not m[i][j] == zero:
+                return False
+
+    upper = min(shape[0], shape[1])
+    for i in range(1, upper):
+        if m[i-1][i-1] == zero:
+            if m[i][i] != zero:
+                return False
+        else:
+            r = domain.div(m[i][i], m[i-1][i-1])[1]
+            if r != zero:
+                return False
+
+    return True
+
+
+def add_columns(m, i, j, a, b, c, d):
+    # replace m[:, i] by a*m[:, i] + b*m[:, j]
+    # and m[:, j] by c*m[:, i] + d*m[:, j]
+    for k in range(len(m)):
+        e = m[k][i]
+        m[k][i] = a*e + b*m[k][j]
+        m[k][j] = c*e + d*m[k][j]
+
+
+def invariant_factors(m):
+    '''
+    Return the tuple of abelian invariants for a matrix `m`
+    (as in the Smith-Normal form)
+
+    References
+    ==========
+
+    [1] https://en.wikipedia.org/wiki/Smith_normal_form#Algorithm
+    [2] https://web.archive.org/web/20200331143852/https://sierra.nmsu.edu/morandi/notes/SmithNormalForm.pdf
+
+    '''
+    domain = m.domain
+    shape = m.shape
+    m = m.to_list()
+    return _smith_normal_decomp(m, domain, shape=shape, full=False)
+
+
+def smith_normal_decomp(m):
+    '''
+    Return the Smith-Normal form decomposition of matrix `m`.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import smith_normal_decomp
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> a, s, t = smith_normal_decomp(m)
+    >>> assert a == s * m * t
+    '''
+    domain = m.domain
+    rows, cols = shape = m.shape
+    m = m.to_list()
+
+    invs, s, t = _smith_normal_decomp(m, domain, shape=shape, full=True)
+    smf = DomainMatrix.diag(invs, domain, shape).to_dense()
+
+    s = DomainMatrix(s, domain=domain, shape=(rows, rows))
+    t = DomainMatrix(t, domain=domain, shape=(cols, cols))
+    return smf, s, t
+
+
+def _smith_normal_decomp(m, domain, shape, full):
+    '''
+    Return the tuple of abelian invariants for a matrix `m`
+    (as in the Smith-Normal form). If `full=True` then invertible matrices
+    ``s, t`` such that the product ``s, m, t`` is the Smith Normal Form
+    are also returned.
+    '''
+    if not domain.is_PID:
+        msg = f"The matrix entries must be over a principal ideal domain, but got {domain}"
+        raise ValueError(msg)
+
+    rows, cols = shape
+    zero = domain.zero
+    one = domain.one
+
+    def eye(n):
+        return [[one if i == j else zero for i in range(n)] for j in range(n)]
+
+    if 0 in shape:
+        if full:
+            return (), eye(rows), eye(cols)
+        else:
+            return ()
+
+    if full:
+        s = eye(rows)
+        t = eye(cols)
+
+    def add_rows(m, i, j, a, b, c, d):
+        # replace m[i, :] by a*m[i, :] + b*m[j, :]
+        # and m[j, :] by c*m[i, :] + d*m[j, :]
+        for k in range(len(m[0])):
+            e = m[i][k]
+            m[i][k] = a*e + b*m[j][k]
+            m[j][k] = c*e + d*m[j][k]
+
+    def clear_column():
+        # make m[1:, 0] zero by row and column operations
+        pivot = m[0][0]
+        for j in range(1, rows):
+            if m[j][0] == zero:
+                continue
+            d, r = domain.div(m[j][0], pivot)
+            if r == zero:
+                add_rows(m, 0, j, 1, 0, -d, 1)
+                if full:
+                    add_rows(s, 0, j, 1, 0, -d, 1)
+            else:
+                a, b, g = domain.gcdex(pivot, m[j][0])
+                d_0 = domain.exquo(m[j][0], g)
+                d_j = domain.exquo(pivot, g)
+                add_rows(m, 0, j, a, b, d_0, -d_j)
+                if full:
+                    add_rows(s, 0, j, a, b, d_0, -d_j)
+                pivot = g
+
+    def clear_row():
+        # make m[0, 1:] zero by row and column operations
+        pivot = m[0][0]
+        for j in range(1, cols):
+            if m[0][j] == zero:
+                continue
+            d, r = domain.div(m[0][j], pivot)
+            if r == zero:
+                add_columns(m, 0, j, 1, 0, -d, 1)
+                if full:
+                    add_columns(t, 0, j, 1, 0, -d, 1)
+            else:
+                a, b, g = domain.gcdex(pivot, m[0][j])
+                d_0 = domain.exquo(m[0][j], g)
+                d_j = domain.exquo(pivot, g)
+                add_columns(m, 0, j, a, b, d_0, -d_j)
+                if full:
+                    add_columns(t, 0, j, a, b, d_0, -d_j)
+                pivot = g
+
+    # permute the rows and columns until m[0,0] is non-zero if possible
+    ind = [i for i in range(rows) if m[i][0] != zero]
+    if ind and ind[0] != zero:
+        m[0], m[ind[0]] = m[ind[0]], m[0]
+        if full:
+            s[0], s[ind[0]] = s[ind[0]], s[0]
+    else:
+        ind = [j for j in range(cols) if m[0][j] != zero]
+        if ind and ind[0] != zero:
+            for row in m:
+                row[0], row[ind[0]] = row[ind[0]], row[0]
+            if full:
+                for row in t:
+                    row[0], row[ind[0]] = row[ind[0]], row[0]
+
+    # make the first row and column except m[0,0] zero
+    while (any(m[0][i] != zero for i in range(1,cols)) or
+           any(m[i][0] != zero for i in range(1,rows))):
+        clear_column()
+        clear_row()
+
+    def to_domain_matrix(m):
+        return DomainMatrix(m, shape=(len(m), len(m[0])), domain=domain)
+
+    if m[0][0] != 0:
+        c = domain.canonical_unit(m[0][0])
+        if domain.is_Field:
+            c = 1 / m[0][0]
+        if c != domain.one:
+            m[0][0] *= c
+            if full:
+                s[0] = [elem * c for elem in s[0]]
+
+    if 1 in shape:
+        invs = ()
+    else:
+        lower_right = [r[1:] for r in m[1:]]
+        ret = _smith_normal_decomp(lower_right, domain,
+                shape=(rows - 1, cols - 1), full=full)
+        if full:
+            invs, s_small, t_small = ret
+            s2 = [[1] + [0]*(rows-1)] + [[0] + row for row in s_small]
+            t2 = [[1] + [0]*(cols-1)] + [[0] + row for row in t_small]
+            s, s2, t, t2 = list(map(to_domain_matrix, [s, s2, t, t2]))
+            s = s2 * s
+            t = t * t2
+            s = s.to_list()
+            t = t.to_list()
+        else:
+            invs = ret
+
+    if m[0][0]:
+        result = [m[0][0]]
+        result.extend(invs)
+        # in case m[0] doesn't divide the invariants of the rest of the matrix
+        for i in range(len(result)-1):
+            a, b = result[i], result[i+1]
+            if b and domain.div(b, a)[1] != zero:
+                if full:
+                    x, y, d = domain.gcdex(a, b)
+                else:
+                    d = domain.gcd(a, b)
+
+                alpha = domain.div(a, d)[0]
+                if full:
+                    beta = domain.div(b, d)[0]
+                    add_rows(s, i, i + 1, 1, 0, x, 1)
+                    add_columns(t, i, i + 1, 1, y, 0, 1)
+                    add_rows(s, i, i + 1, 1, -alpha, 0, 1)
+                    add_columns(t, i, i + 1, 1, 0, -beta, 1)
+                    add_rows(s, i, i + 1, 0, 1, -1, 0)
+
+                result[i+1] = b * alpha
+                result[i] = d
+            else:
+                break
+    else:
+        if full:
+            if rows > 1:
+                s = s[1:] + [s[0]]
+            if cols > 1:
+                t = [row[1:] + [row[0]] for row in t]
+        result = invs + (m[0][0],)
+
+    if full:
+        return tuple(result), s, t
+    else:
+        return tuple(result)
+
+
+def _gcdex(a, b):
+    r"""
+    This supports the functions that compute Hermite Normal Form.
+
+    Explanation
+    ===========
+
+    Let x, y be the coefficients returned by the extended Euclidean
+    Algorithm, so that x*a + y*b = g. In the algorithms for computing HNF,
+    it is critical that x, y not only satisfy the condition of being small
+    in magnitude -- namely that |x| <= |b|/g, |y| <- |a|/g -- but also that
+    y == 0 when a | b.
+
+    """
+    x, y, g = ZZ.gcdex(a, b)
+    if a != 0 and b % a == 0:
+        y = 0
+        x = -1 if a < 0 else 1
+    return x, y, g
+
+
+def _hermite_normal_form(A):
+    r"""
+    Compute the Hermite Normal Form of DomainMatrix *A* over :ref:`ZZ`.
+
+    Parameters
+    ==========
+
+    A : :py:class:`~.DomainMatrix` over domain :ref:`ZZ`.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 2.4.5.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    # We work one row at a time, starting from the bottom row, and working our
+    # way up.
+    m, n = A.shape
+    A = A.to_ddm().copy()
+    # Our goal is to put pivot entries in the rightmost columns.
+    # Invariant: Before processing each row, k should be the index of the
+    # leftmost column in which we have so far put a pivot.
+    k = n
+    for i in range(m - 1, -1, -1):
+        if k == 0:
+            # This case can arise when n < m and we've already found n pivots.
+            # We don't need to consider any more rows, because this is already
+            # the maximum possible number of pivots.
+            break
+        k -= 1
+        # k now points to the column in which we want to put a pivot.
+        # We want zeros in all entries to the left of the pivot column.
+        for j in range(k - 1, -1, -1):
+            if A[i][j] != 0:
+                # Replace cols j, k by lin combs of these cols such that, in row i,
+                # col j has 0, while col k has the gcd of their row i entries. Note
+                # that this ensures a nonzero entry in col k.
+                u, v, d = _gcdex(A[i][k], A[i][j])
+                r, s = A[i][k] // d, A[i][j] // d
+                add_columns(A, k, j, u, v, -s, r)
+        b = A[i][k]
+        # Do not want the pivot entry to be negative.
+        if b < 0:
+            add_columns(A, k, k, -1, 0, -1, 0)
+            b = -b
+        # The pivot entry will be 0 iff the row was 0 from the pivot col all the
+        # way to the left. In this case, we are still working on the same pivot
+        # col for the next row. Therefore:
+        if b == 0:
+            k += 1
+        # If the pivot entry is nonzero, then we want to reduce all entries to its
+        # right in the sense of the division algorithm, i.e. make them all remainders
+        # w.r.t. the pivot as divisor.
+        else:
+            for j in range(k + 1, n):
+                q = A[i][j] // b
+                add_columns(A, j, k, 1, -q, 0, 1)
+    # Finally, the HNF consists of those columns of A in which we succeeded in making
+    # a nonzero pivot.
+    return DomainMatrix.from_rep(A.to_dfm_or_ddm())[:, k:]
+
+
+def _hermite_normal_form_modulo_D(A, D):
+    r"""
+    Perform the mod *D* Hermite Normal Form reduction algorithm on
+    :py:class:`~.DomainMatrix` *A*.
+
+    Explanation
+    ===========
+
+    If *A* is an $m \times n$ matrix of rank $m$, having Hermite Normal Form
+    $W$, and if *D* is any positive integer known in advance to be a multiple
+    of $\det(W)$, then the HNF of *A* can be computed by an algorithm that
+    works mod *D* in order to prevent coefficient explosion.
+
+    Parameters
+    ==========
+
+    A : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+        $m \times n$ matrix, having rank $m$.
+    D : :ref:`ZZ`
+        Positive integer, known to be a multiple of the determinant of the
+        HNF of *A*.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`, or
+        if *D* is given but is not in :ref:`ZZ`.
+
+    DMShapeError
+        If the matrix has more rows than columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 2.4.8.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    if not ZZ.of_type(D) or D < 1:
+        raise DMDomainError('Modulus D must be positive element of domain ZZ.')
+
+    def add_columns_mod_R(m, R, i, j, a, b, c, d):
+        # replace m[:, i] by (a*m[:, i] + b*m[:, j]) % R
+        # and m[:, j] by (c*m[:, i] + d*m[:, j]) % R
+        for k in range(len(m)):
+            e = m[k][i]
+            m[k][i] = symmetric_residue((a * e + b * m[k][j]) % R, R)
+            m[k][j] = symmetric_residue((c * e + d * m[k][j]) % R, R)
+
+    W = defaultdict(dict)
+
+    m, n = A.shape
+    if n < m:
+        raise DMShapeError('Matrix must have at least as many columns as rows.')
+    A = A.to_list()
+    k = n
+    R = D
+    for i in range(m - 1, -1, -1):
+        k -= 1
+        for j in range(k - 1, -1, -1):
+            if A[i][j] != 0:
+                u, v, d = _gcdex(A[i][k], A[i][j])
+                r, s = A[i][k] // d, A[i][j] // d
+                add_columns_mod_R(A, R, k, j, u, v, -s, r)
+        b = A[i][k]
+        if b == 0:
+            A[i][k] = b = R
+        u, v, d = _gcdex(b, R)
+        for ii in range(m):
+            W[ii][i] = u*A[ii][k] % R
+        if W[i][i] == 0:
+            W[i][i] = R
+        for j in range(i + 1, m):
+            q = W[i][j] // W[i][i]
+            add_columns(W, j, i, 1, -q, 0, 1)
+        R //= d
+    return DomainMatrix(W, (m, m), ZZ).to_dense()
+
+
+def hermite_normal_form(A, *, D=None, check_rank=False):
+    r"""
+    Compute the Hermite Normal Form of :py:class:`~.DomainMatrix` *A* over
+    :ref:`ZZ`.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import hermite_normal_form
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> print(hermite_normal_form(m).to_Matrix())
+    Matrix([[10, 0, 2], [0, 15, 3], [0, 0, 2]])
+
+    Parameters
+    ==========
+
+    A : $m \times n$ ``DomainMatrix`` over :ref:`ZZ`.
+
+    D : :ref:`ZZ`, optional
+        Let $W$ be the HNF of *A*. If known in advance, a positive integer *D*
+        being any multiple of $\det(W)$ may be provided. In this case, if *A*
+        also has rank $m$, then we may use an alternative algorithm that works
+        mod *D* in order to prevent coefficient explosion.
+
+    check_rank : boolean, optional (default=False)
+        The basic assumption is that, if you pass a value for *D*, then
+        you already believe that *A* has rank $m$, so we do not waste time
+        checking it for you. If you do want this to be checked (and the
+        ordinary, non-modulo *D* algorithm to be used if the check fails), then
+        set *check_rank* to ``True``.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`, or
+        if *D* is given but is not in :ref:`ZZ`.
+
+    DMShapeError
+        If the mod *D* algorithm is used but the matrix has more rows than
+        columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithms 2.4.5 and 2.4.8.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    if D is not None and (not check_rank or A.convert_to(QQ).rank() == A.shape[0]):
+        return _hermite_normal_form_modulo_D(A, D)
+    else:
+        return _hermite_normal_form(A)

venv/lib/python3.12/site-packages/sympy/polys/matrices/rref.py

@@ -0,0 +1,422 @@
+# Algorithms for computing the reduced row echelon form of a matrix.
+#
+# We need to choose carefully which algorithms to use depending on the domain,
+# shape, and sparsity of the matrix as well as things like the bit count in the
+# case of ZZ or QQ. This is important because the algorithms have different
+# performance characteristics in the extremes of dense vs sparse.
+#
+# In all cases we use the sparse implementations but we need to choose between
+# Gauss-Jordan elimination with division and fraction-free Gauss-Jordan
+# elimination. For very sparse matrices over ZZ with low bit counts it is
+# asymptotically faster to use Gauss-Jordan elimination with division. For
+# dense matrices with high bit counts it is asymptotically faster to use
+# fraction-free Gauss-Jordan.
+#
+# The most important thing is to get the extreme cases right because it can
+# make a big difference. In between the extremes though we have to make a
+# choice and here we use empirically determined thresholds based on timings
+# with random sparse matrices.
+#
+# In the case of QQ we have to consider the denominators as well. If the
+# denominators are small then it is faster to clear them and use fraction-free
+# Gauss-Jordan over ZZ. If the denominators are large then it is faster to use
+# Gauss-Jordan elimination with division over QQ.
+#
+# Timings for the various algorithms can be found at
+#
+#   https://github.com/sympy/sympy/issues/25410
+#   https://github.com/sympy/sympy/pull/25443
+
+from sympy.polys.domains import ZZ
+
+from sympy.polys.matrices.sdm import SDM, sdm_irref, sdm_rref_den
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.dense import ddm_irref, ddm_irref_den
+
+
+def _dm_rref(M, *, method='auto'):
+    """
+    Compute the reduced row echelon form of a ``DomainMatrix``.
+
+    This function is the implementation of :meth:`DomainMatrix.rref`.
+
+    Chooses the best algorithm depending on the domain, shape, and sparsity of
+    the matrix as well as things like the bit count in the case of :ref:`ZZ` or
+    :ref:`QQ`. The result is returned over the field associated with the domain
+    of the Matrix.
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref
+        The ``DomainMatrix`` method that calls this function.
+    sympy.polys.matrices.rref._dm_rref_den
+        Alternative function for computing RREF with denominator.
+    """
+    method, use_fmt = _dm_rref_choose_method(M, method, denominator=False)
+
+    M, old_fmt = _dm_to_fmt(M, use_fmt)
+
+    if method == 'GJ':
+        # Use Gauss-Jordan with division over the associated field.
+        Mf = _to_field(M)
+        M_rref, pivots = _dm_rref_GJ(Mf)
+
+    elif method == 'FF':
+        # Use fraction-free GJ over the current domain.
+        M_rref_f, den, pivots = _dm_rref_den_FF(M)
+        M_rref = _to_field(M_rref_f) / den
+
+    elif method == 'CD':
+        # Clear denominators and use fraction-free GJ in the associated ring.
+        _, Mr = M.clear_denoms_rowwise(convert=True)
+        M_rref_f, den, pivots = _dm_rref_den_FF(Mr)
+        M_rref = _to_field(M_rref_f) / den
+
+    else:
+        raise ValueError(f"Unknown method for rref: {method}")
+
+    M_rref, _ = _dm_to_fmt(M_rref, old_fmt)
+
+    # Invariants:
+    #   - M_rref is in the same format (sparse or dense) as the input matrix.
+    #   - M_rref is in the associated field domain and any denominator was
+    #     divided in (so is implicitly 1 now).
+
+    return M_rref, pivots
+
+
+def _dm_rref_den(M, *, keep_domain=True, method='auto'):
+    """
+    Compute the reduced row echelon form of a ``DomainMatrix`` with denominator.
+
+    This function is the implementation of :meth:`DomainMatrix.rref_den`.
+
+    Chooses the best algorithm depending on the domain, shape, and sparsity of
+    the matrix as well as things like the bit count in the case of :ref:`ZZ` or
+    :ref:`QQ`. The result is returned over the same domain as the input matrix
+    unless ``keep_domain=False`` in which case the result might be over an
+    associated ring or field domain.
+
+    See Also
+    ========
+
+    sympy.polys.matrices.domainmatrix.DomainMatrix.rref_den
+        The ``DomainMatrix`` method that calls this function.
+    sympy.polys.matrices.rref._dm_rref
+        Alternative function for computing RREF without denominator.
+    """
+    method, use_fmt = _dm_rref_choose_method(M, method, denominator=True)
+
+    M, old_fmt = _dm_to_fmt(M, use_fmt)
+
+    if method == 'FF':
+        # Use fraction-free GJ over the current domain.
+        M_rref, den, pivots = _dm_rref_den_FF(M)
+
+    elif method == 'GJ':
+        # Use Gauss-Jordan with division over the associated field.
+        M_rref_f, pivots = _dm_rref_GJ(_to_field(M))
+
+        # Convert back to the ring?
+        if keep_domain and M_rref_f.domain != M.domain:
+            _, M_rref = M_rref_f.clear_denoms(convert=True)
+
+            if pivots:
+                den = M_rref[0, pivots[0]].element
+            else:
+                den = M_rref.domain.one
+        else:
+            # Possibly an associated field
+            M_rref = M_rref_f
+            den = M_rref.domain.one
+
+    elif method == 'CD':
+        # Clear denominators and use fraction-free GJ in the associated ring.
+        _, Mr = M.clear_denoms_rowwise(convert=True)
+
+        M_rref_r, den, pivots = _dm_rref_den_FF(Mr)
+
+        if keep_domain and M_rref_r.domain != M.domain:
+            # Convert back to the field
+            M_rref = _to_field(M_rref_r) / den
+            den = M.domain.one
+        else:
+            # Possibly an associated ring
+            M_rref = M_rref_r
+
+            if pivots:
+                den = M_rref[0, pivots[0]].element
+            else:
+                den = M_rref.domain.one
+    else:
+        raise ValueError(f"Unknown method for rref: {method}")
+
+    M_rref, _ = _dm_to_fmt(M_rref, old_fmt)
+
+    # Invariants:
+    #   - M_rref is in the same format (sparse or dense) as the input matrix.
+    #   - If keep_domain=True then M_rref and den are in the same domain as the
+    #     input matrix
+    #   - If keep_domain=False then M_rref might be in an associated ring or
+    #     field domain but den is always in the same domain as M_rref.
+
+    return M_rref, den, pivots
+
+
+def _dm_to_fmt(M, fmt):
+    """Convert a matrix to the given format and return the old format."""
+    old_fmt = M.rep.fmt
+    if old_fmt == fmt:
+        pass
+    elif fmt == 'dense':
+        M = M.to_dense()
+    elif fmt == 'sparse':
+        M = M.to_sparse()
+    else:
+        raise ValueError(f'Unknown format: {fmt}') # pragma: no cover
+    return M, old_fmt
+
+
+# These are the four basic implementations that we want to choose between:
+
+
+def _dm_rref_GJ(M):
+    """Compute RREF using Gauss-Jordan elimination with division."""
+    if M.rep.fmt == 'sparse':
+        return _dm_rref_GJ_sparse(M)
+    else:
+        return _dm_rref_GJ_dense(M)
+
+
+def _dm_rref_den_FF(M):
+    """Compute RREF using fraction-free Gauss-Jordan elimination."""
+    if M.rep.fmt == 'sparse':
+        return _dm_rref_den_FF_sparse(M)
+    else:
+        return _dm_rref_den_FF_dense(M)
+
+
+def _dm_rref_GJ_sparse(M):
+    """Compute RREF using sparse Gauss-Jordan elimination with division."""
+    M_rref_d, pivots, _ = sdm_irref(M.rep)
+    M_rref_sdm = SDM(M_rref_d, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_sdm), pivots
+
+
+def _dm_rref_GJ_dense(M):
+    """Compute RREF using dense Gauss-Jordan elimination with division."""
+    partial_pivot = M.domain.is_RR or M.domain.is_CC
+    ddm = M.rep.to_ddm().copy()
+    pivots = ddm_irref(ddm, _partial_pivot=partial_pivot)
+    M_rref_ddm = DDM(ddm, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_ddm.to_dfm_or_ddm()), pivots
+
+
+def _dm_rref_den_FF_sparse(M):
+    """Compute RREF using sparse fraction-free Gauss-Jordan elimination."""
+    M_rref_d, den, pivots = sdm_rref_den(M.rep, M.domain)
+    M_rref_sdm = SDM(M_rref_d, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_sdm), den, pivots
+
+
+def _dm_rref_den_FF_dense(M):
+    """Compute RREF using sparse fraction-free Gauss-Jordan elimination."""
+    ddm = M.rep.to_ddm().copy()
+    den, pivots = ddm_irref_den(ddm, M.domain)
+    M_rref_ddm = DDM(ddm, M.shape, M.domain)
+    pivots = tuple(pivots)
+    return M.from_rep(M_rref_ddm.to_dfm_or_ddm()), den, pivots
+
+
+def _dm_rref_choose_method(M, method, *, denominator=False):
+    """Choose the fastest method for computing RREF for M."""
+
+    if method != 'auto':
+        if method.endswith('_dense'):
+            method = method[:-len('_dense')]
+            use_fmt = 'dense'
+        else:
+            use_fmt = 'sparse'
+
+    else:
+        # The sparse implementations are always faster
+        use_fmt = 'sparse'
+
+        K = M.domain
+
+        if K.is_ZZ:
+            method = _dm_rref_choose_method_ZZ(M, denominator=denominator)
+        elif K.is_QQ:
+            method = _dm_rref_choose_method_QQ(M, denominator=denominator)
+        elif K.is_RR or K.is_CC:
+            # TODO: Add partial pivot support to the sparse implementations.
+            method = 'GJ'
+            use_fmt = 'dense'
+        elif K.is_EX and M.rep.fmt == 'dense' and not denominator:
+            # Do not switch to the sparse implementation for EX because the
+            # domain does not have proper canonicalization and the sparse
+            # implementation gives equivalent but non-identical results over EX
+            # from performing arithmetic in a different order. Specifically
+            # test_issue_23718 ends up getting a more complicated expression
+            # when using the sparse implementation. Probably the best fix for
+            # this is something else but for now we stick with the dense
+            # implementation for EX if the matrix is already dense.
+            method = 'GJ'
+            use_fmt = 'dense'
+        else:
+            # This is definitely suboptimal. More work is needed to determine
+            # the best method for computing RREF over different domains.
+            if denominator:
+                method = 'FF'
+            else:
+                method = 'GJ'
+
+    return method, use_fmt
+
+
+def _dm_rref_choose_method_QQ(M, *, denominator=False):
+    """Choose the fastest method for computing RREF over QQ."""
+    # The same sorts of considerations apply here as in the case of ZZ. Here
+    # though a new more significant consideration is what sort of denominators
+    # we have and what to do with them so we focus on that.
+
+    # First compute the density. This is the average number of non-zero entries
+    # per row but only counting rows that have at least one non-zero entry
+    # since RREF can ignore fully zero rows.
+    density, _, ncols = _dm_row_density(M)
+
+    # For sparse matrices use Gauss-Jordan elimination over QQ regardless.
+    if density < min(5, ncols/2):
+        return 'GJ'
+
+    # Compare the bit-length of the lcm of the denominators to the bit length
+    # of the numerators.
+    #
+    # The threshold here is empirical: we prefer rref over QQ if clearing
+    # denominators would result in a numerator matrix having 5x the bit size of
+    # the current numerators.
+    numers, denoms = _dm_QQ_numers_denoms(M)
+    numer_bits = max([n.bit_length() for n in numers], default=1)
+
+    denom_lcm = ZZ.one
+    for d in denoms:
+        denom_lcm = ZZ.lcm(denom_lcm, d)
+        if denom_lcm.bit_length() > 5*numer_bits:
+            return 'GJ'
+
+    # If we get here then the matrix is dense and the lcm of the denominators
+    # is not too large compared to the numerators. For particularly small
+    # denominators it is fastest just to clear them and use fraction-free
+    # Gauss-Jordan over ZZ. With very small denominators this is a little
+    # faster than using rref_den over QQ but there is an intermediate regime
+    # where rref_den over QQ is significantly faster. The small denominator
+    # case is probably very common because small fractions like 1/2 or 1/3 are
+    # often seen in user inputs.
+
+    if denom_lcm.bit_length() < 50:
+        return 'CD'
+    else:
+        return 'FF'
+
+
+def _dm_rref_choose_method_ZZ(M, *, denominator=False):
+    """Choose the fastest method for computing RREF over ZZ."""
+    # In the extreme of very sparse matrices and low bit counts it is faster to
+    # use Gauss-Jordan elimination over QQ rather than fraction-free
+    # Gauss-Jordan over ZZ. In the opposite extreme of dense matrices and high
+    # bit counts it is faster to use fraction-free Gauss-Jordan over ZZ. These
+    # two extreme cases need to be handled differently because they lead to
+    # different asymptotic complexities. In between these two extremes we need
+    # a threshold for deciding which method to use. This threshold is
+    # determined empirically by timing the two methods with random matrices.
+
+    # The disadvantage of using empirical timings is that future optimisations
+    # might change the relative speeds so this can easily become out of date.
+    # The main thing is to get the asymptotic complexity right for the extreme
+    # cases though so the precise value of the threshold is hopefully not too
+    # important.
+
+    # Empirically determined parameter.
+    PARAM = 10000
+
+    # First compute the density. This is the average number of non-zero entries
+    # per row but only counting rows that have at least one non-zero entry
+    # since RREF can ignore fully zero rows.
+    density, nrows_nz, ncols = _dm_row_density(M)
+
+    # For small matrices use QQ if more than half the entries are zero.
+    if nrows_nz < 10:
+        if density < ncols/2:
+            return 'GJ'
+        else:
+            return 'FF'
+
+    # These are just shortcuts for the formula below.
+    if density < 5:
+        return 'GJ'
+    elif density > 5 + PARAM/nrows_nz:
+        return 'FF'  # pragma: no cover
+
+    # Maximum bitsize of any entry.
+    elements = _dm_elements(M)
+    bits = max([e.bit_length() for e in elements], default=1)
+
+    # Wideness parameter. This is 1 for square or tall matrices but >1 for wide
+    # matrices.
+    wideness = max(1, 2/3*ncols/nrows_nz)
+
+    max_density = (5 + PARAM/(nrows_nz*bits**2)) * wideness
+
+    if density < max_density:
+        return 'GJ'
+    else:
+        return 'FF'
+
+
+def _dm_row_density(M):
+    """Density measure for sparse matrices.
+
+    Defines the "density", ``d`` as the average number of non-zero entries per
+    row except ignoring rows that are fully zero. RREF can ignore fully zero
+    rows so they are excluded. By definition ``d >= 1`` except that we define
+    ``d = 0`` for the zero matrix.
+
+    Returns ``(density, nrows_nz, ncols)`` where ``nrows_nz`` counts the number
+    of nonzero rows and ``ncols`` is the number of columns.
+    """
+    # Uses the SDM dict-of-dicts representation.
+    ncols = M.shape[1]
+    rows_nz = M.rep.to_sdm().values()
+    if not rows_nz:
+        return 0, 0, ncols
+    else:
+        nrows_nz = len(rows_nz)
+        density = sum(map(len, rows_nz)) / nrows_nz
+        return density, nrows_nz, ncols
+
+
+def _dm_elements(M):
+    """Return nonzero elements of a DomainMatrix."""
+    elements, _ = M.to_flat_nz()
+    return elements
+
+
+def _dm_QQ_numers_denoms(Mq):
+    """Returns the numerators and denominators of a DomainMatrix over QQ."""
+    elements = _dm_elements(Mq)
+    numers = [e.numerator for e in elements]
+    denoms = [e.denominator for e in elements]
+    return numers, denoms
+
+
+def _to_field(M):
+    """Convert a DomainMatrix to a field if possible."""
+    K = M.domain
+    if K.has_assoc_Field:
+        return M.to_field()
+    else:
+        return M

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_ddm.py

@@ -0,0 +1,558 @@
+from sympy.testing.pytest import raises
+from sympy.external.gmpy import GROUND_TYPES
+
+from sympy.polys import ZZ, QQ
+
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.exceptions import (
+    DMShapeError, DMNonInvertibleMatrixError, DMDomainError,
+    DMBadInputError)
+
+
+def test_DDM_init():
+    items = [[ZZ(0), ZZ(1), ZZ(2)], [ZZ(3), ZZ(4), ZZ(5)]]
+    shape = (2, 3)
+    ddm = DDM(items, shape, ZZ)
+    assert ddm.shape == shape
+    assert ddm.rows == 2
+    assert ddm.cols == 3
+    assert ddm.domain == ZZ
+
+    raises(DMBadInputError, lambda: DDM([[ZZ(2), ZZ(3)]], (2, 2), ZZ))
+    raises(DMBadInputError, lambda: DDM([[ZZ(1)], [ZZ(2), ZZ(3)]], (2, 2), ZZ))
+
+
+def test_DDM_getsetitem():
+    ddm = DDM([[ZZ(2), ZZ(3)], [ZZ(4), ZZ(5)]], (2, 2), ZZ)
+
+    assert ddm[0][0] == ZZ(2)
+    assert ddm[0][1] == ZZ(3)
+    assert ddm[1][0] == ZZ(4)
+    assert ddm[1][1] == ZZ(5)
+
+    raises(IndexError, lambda: ddm[2][0])
+    raises(IndexError, lambda: ddm[0][2])
+
+    ddm[0][0] = ZZ(-1)
+    assert ddm[0][0] == ZZ(-1)
+
+
+def test_DDM_str():
+    ddm = DDM([[ZZ(0), ZZ(1)], [ZZ(2), ZZ(3)]], (2, 2), ZZ)
+    if GROUND_TYPES == 'gmpy': # pragma: no cover
+        assert str(ddm) == '[[0, 1], [2, 3]]'
+        assert repr(ddm) == 'DDM([[mpz(0), mpz(1)], [mpz(2), mpz(3)]], (2, 2), ZZ)'
+    else:        # pragma: no cover
+        assert repr(ddm) == 'DDM([[0, 1], [2, 3]], (2, 2), ZZ)'
+        assert str(ddm) == '[[0, 1], [2, 3]]'
+
+
+def test_DDM_eq():
+    items = [[ZZ(0), ZZ(1)], [ZZ(2), ZZ(3)]]
+    ddm1 = DDM(items, (2, 2), ZZ)
+    ddm2 = DDM(items, (2, 2), ZZ)
+
+    assert (ddm1 == ddm1) is True
+    assert (ddm1 == items) is False
+    assert (items == ddm1) is False
+    assert (ddm1 == ddm2) is True
+    assert (ddm2 == ddm1) is True
+
+    assert (ddm1 != ddm1) is False
+    assert (ddm1 != items) is True
+    assert (items != ddm1) is True
+    assert (ddm1 != ddm2) is False
+    assert (ddm2 != ddm1) is False
+
+    ddm3 = DDM([[ZZ(0), ZZ(1)], [ZZ(3), ZZ(3)]], (2, 2), ZZ)
+    ddm3 = DDM(items, (2, 2), QQ)
+
+    assert (ddm1 == ddm3) is False
+    assert (ddm3 == ddm1) is False
+    assert (ddm1 != ddm3) is True
+    assert (ddm3 != ddm1) is True
+
+
+def test_DDM_convert_to():
+    ddm = DDM([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    assert ddm.convert_to(ZZ) == ddm
+    ddmq = ddm.convert_to(QQ)
+    assert ddmq.domain == QQ
+
+
+def test_DDM_zeros():
+    ddmz = DDM.zeros((3, 4), QQ)
+    assert list(ddmz) == [[QQ(0)] * 4] * 3
+    assert ddmz.shape == (3, 4)
+    assert ddmz.domain == QQ
+
+def test_DDM_ones():
+    ddmone = DDM.ones((2, 3), QQ)
+    assert list(ddmone) == [[QQ(1)] * 3] * 2
+    assert ddmone.shape == (2, 3)
+    assert ddmone.domain == QQ
+
+def test_DDM_eye():
+    ddmz = DDM.eye(3, QQ)
+    f = lambda i, j: QQ(1) if i == j else QQ(0)
+    assert list(ddmz) == [[f(i, j) for i in range(3)] for j in range(3)]
+    assert ddmz.shape == (3, 3)
+    assert ddmz.domain == QQ
+
+
+def test_DDM_copy():
+    ddm1 = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    ddm2 = ddm1.copy()
+    assert (ddm1 == ddm2) is True
+    ddm1[0][0] = QQ(-1)
+    assert (ddm1 == ddm2) is False
+    ddm2[0][0] = QQ(-1)
+    assert (ddm1 == ddm2) is True
+
+
+def test_DDM_transpose():
+    ddm = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    ddmT = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    assert ddm.transpose() == ddmT
+    ddm02 = DDM([], (0, 2), QQ)
+    ddm02T = DDM([[], []], (2, 0), QQ)
+    assert ddm02.transpose() == ddm02T
+    assert ddm02T.transpose() == ddm02
+    ddm0 = DDM([], (0, 0), QQ)
+    assert ddm0.transpose() == ddm0
+
+
+def test_DDM_add():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    B = DDM([[ZZ(3)], [ZZ(4)]], (2, 1), ZZ)
+    C = DDM([[ZZ(4)], [ZZ(6)]], (2, 1), ZZ)
+    AQ = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    assert A + B == A.add(B) == C
+
+    raises(DMShapeError, lambda: A + DDM([[ZZ(5)]], (1, 1), ZZ))
+    raises(TypeError, lambda: A + ZZ(1))
+    raises(TypeError, lambda: ZZ(1) + A)
+    raises(DMDomainError, lambda: A + AQ)
+    raises(DMDomainError, lambda: AQ + A)
+
+
+def test_DDM_sub():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    B = DDM([[ZZ(3)], [ZZ(4)]], (2, 1), ZZ)
+    C = DDM([[ZZ(-2)], [ZZ(-2)]], (2, 1), ZZ)
+    AQ = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    D = DDM([[ZZ(5)]], (1, 1), ZZ)
+    assert A - B == A.sub(B) == C
+
+    raises(TypeError, lambda: A - ZZ(1))
+    raises(TypeError, lambda: ZZ(1) - A)
+    raises(DMShapeError, lambda: A - D)
+    raises(DMShapeError, lambda: D - A)
+    raises(DMShapeError, lambda: A.sub(D))
+    raises(DMShapeError, lambda: D.sub(A))
+    raises(DMDomainError, lambda: A - AQ)
+    raises(DMDomainError, lambda: AQ - A)
+    raises(DMDomainError, lambda: A.sub(AQ))
+    raises(DMDomainError, lambda: AQ.sub(A))
+
+
+def test_DDM_neg():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    An = DDM([[ZZ(-1)], [ZZ(-2)]], (2, 1), ZZ)
+    assert -A == A.neg() == An
+    assert -An == An.neg() == A
+
+
+def test_DDM_mul():
+    A = DDM([[ZZ(1)]], (1, 1), ZZ)
+    A2 = DDM([[ZZ(2)]], (1, 1), ZZ)
+    assert A * ZZ(2) == A2
+    assert ZZ(2) * A == A2
+    raises(TypeError, lambda: [[1]] * A)
+    raises(TypeError, lambda: A * [[1]])
+
+
+def test_DDM_matmul():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    B = DDM([[ZZ(3), ZZ(4)]], (1, 2), ZZ)
+    AB = DDM([[ZZ(3), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
+    BA = DDM([[ZZ(11)]], (1, 1), ZZ)
+
+    assert A @ B == A.matmul(B) == AB
+    assert B @ A == B.matmul(A) == BA
+
+    raises(TypeError, lambda: A @ 1)
+    raises(TypeError, lambda: A @ [[3, 4]])
+
+    Bq = DDM([[QQ(3), QQ(4)]], (1, 2), QQ)
+
+    raises(DMDomainError, lambda: A @ Bq)
+    raises(DMDomainError, lambda: Bq @ A)
+
+    C = DDM([[ZZ(1)]], (1, 1), ZZ)
+
+    assert A @ C == A.matmul(C) == A
+
+    raises(DMShapeError, lambda: C @ A)
+    raises(DMShapeError, lambda: C.matmul(A))
+
+    Z04 = DDM([], (0, 4), ZZ)
+    Z40 = DDM([[]]*4, (4, 0), ZZ)
+    Z50 = DDM([[]]*5, (5, 0), ZZ)
+    Z05 = DDM([], (0, 5), ZZ)
+    Z45 = DDM([[0] * 5] * 4, (4, 5), ZZ)
+    Z54 = DDM([[0] * 4] * 5, (5, 4), ZZ)
+    Z00 = DDM([], (0, 0), ZZ)
+
+    assert Z04 @ Z45 == Z04.matmul(Z45) == Z05
+    assert Z45 @ Z50 == Z45.matmul(Z50) == Z40
+    assert Z00 @ Z04 == Z00.matmul(Z04) == Z04
+    assert Z50 @ Z00 == Z50.matmul(Z00) == Z50
+    assert Z00 @ Z00 == Z00.matmul(Z00) == Z00
+    assert Z50 @ Z04 == Z50.matmul(Z04) == Z54
+
+    raises(DMShapeError, lambda: Z05 @ Z40)
+    raises(DMShapeError, lambda: Z05.matmul(Z40))
+
+
+def test_DDM_hstack():
+    A = DDM([[ZZ(1), ZZ(2), ZZ(3)]], (1, 3), ZZ)
+    B = DDM([[ZZ(4), ZZ(5)]], (1, 2), ZZ)
+    C = DDM([[ZZ(6)]], (1, 1), ZZ)
+
+    Ah = A.hstack(B)
+    assert Ah.shape == (1, 5)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1), ZZ(2), ZZ(3), ZZ(4), ZZ(5)]], (1, 5), ZZ)
+
+    Ah = A.hstack(B, C)
+    assert Ah.shape == (1, 6)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1), ZZ(2), ZZ(3), ZZ(4), ZZ(5), ZZ(6)]], (1, 6), ZZ)
+
+
+def test_DDM_vstack():
+    A = DDM([[ZZ(1)], [ZZ(2)], [ZZ(3)]], (3, 1), ZZ)
+    B = DDM([[ZZ(4)], [ZZ(5)]], (2, 1), ZZ)
+    C = DDM([[ZZ(6)]], (1, 1), ZZ)
+
+    Ah = A.vstack(B)
+    assert Ah.shape == (5, 1)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1)], [ZZ(2)], [ZZ(3)], [ZZ(4)], [ZZ(5)]], (5, 1), ZZ)
+
+    Ah = A.vstack(B, C)
+    assert Ah.shape == (6, 1)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1)], [ZZ(2)], [ZZ(3)], [ZZ(4)], [ZZ(5)], [ZZ(6)]], (6, 1), ZZ)
+
+
+def test_DDM_applyfunc():
+    A = DDM([[ZZ(1), ZZ(2), ZZ(3)]], (1, 3), ZZ)
+    B = DDM([[ZZ(2), ZZ(4), ZZ(6)]], (1, 3), ZZ)
+    assert A.applyfunc(lambda x: 2*x, ZZ) == B
+
+def test_DDM_rref():
+
+    A = DDM([], (0, 4), QQ)
+    assert A.rref() == (A, [])
+
+    A = DDM([[QQ(0), QQ(1)], [QQ(1), QQ(1)]], (2, 2), QQ)
+    Ar = DDM([[QQ(1), QQ(0)], [QQ(0), QQ(1)]], (2, 2), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(1), QQ(2), QQ(1)], [QQ(3), QQ(4), QQ(1)]], (2, 3), QQ)
+    Ar = DDM([[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]], (2, 3), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(3), QQ(4), QQ(1)], [QQ(1), QQ(2), QQ(1)]], (2, 3), QQ)
+    Ar = DDM([[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]], (2, 3), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(1), QQ(0)], [QQ(1), QQ(3)], [QQ(0), QQ(1)]], (3, 2), QQ)
+    Ar = DDM([[QQ(1), QQ(0)], [QQ(0), QQ(1)], [QQ(0), QQ(0)]], (3, 2), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(1), QQ(0), QQ(1)], [QQ(3), QQ(0), QQ(1)]], (2, 3), QQ)
+    Ar = DDM([[QQ(1), QQ(0), QQ(0)], [QQ(0), QQ(0), QQ(1)]], (2, 3), QQ)
+    pivots = [0, 2]
+    assert A.rref() == (Ar, pivots)
+
+
+def test_DDM_nullspace():
+    # more tests are in test_nullspace.py
+    A = DDM([[QQ(1), QQ(1)], [QQ(1), QQ(1)]], (2, 2), QQ)
+    Anull = DDM([[QQ(-1), QQ(1)]], (1, 2), QQ)
+    nonpivots = [1]
+    assert A.nullspace() == (Anull, nonpivots)
+
+
+def test_DDM_particular():
+    A = DDM([[QQ(1), QQ(0)]], (1, 2), QQ)
+    assert A.particular() == DDM.zeros((1, 1), QQ)
+
+
+def test_DDM_det():
+    # 0x0 case
+    A = DDM([], (0, 0), ZZ)
+    assert A.det() == ZZ(1)
+
+    # 1x1 case
+    A = DDM([[ZZ(2)]], (1, 1), ZZ)
+    assert A.det() == ZZ(2)
+
+    # 2x2 case
+    A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.det() == ZZ(-2)
+
+    # 3x3 with swap
+    A = DDM([[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(2), ZZ(5)]], (3, 3), ZZ)
+    assert A.det() == ZZ(0)
+
+    # 2x2 QQ case
+    A = DDM([[QQ(1, 2), QQ(1, 2)], [QQ(1, 3), QQ(1, 4)]], (2, 2), QQ)
+    assert A.det() == QQ(-1, 24)
+
+    # Nonsquare error
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    raises(DMShapeError, lambda: A.det())
+
+    # Nonsquare error with empty matrix
+    A = DDM([], (0, 1), ZZ)
+    raises(DMShapeError, lambda: A.det())
+
+
+def test_DDM_inv():
+    A = DDM([[QQ(1, 1), QQ(2, 1)], [QQ(3, 1), QQ(4, 1)]], (2, 2), QQ)
+    Ainv = DDM([[QQ(-2, 1), QQ(1, 1)], [QQ(3, 2), QQ(-1, 2)]], (2, 2), QQ)
+    assert A.inv() == Ainv
+
+    A = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    raises(DMShapeError, lambda: A.inv())
+
+    A = DDM([[ZZ(2)]], (1, 1), ZZ)
+    raises(DMDomainError, lambda: A.inv())
+
+    A = DDM([], (0, 0), QQ)
+    assert A.inv() == A
+
+    A = DDM([[QQ(1), QQ(2)], [QQ(2), QQ(4)]], (2, 2), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+def test_DDM_lu():
+    A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    L, U, swaps = A.lu()
+    assert L == DDM([[QQ(1), QQ(0)], [QQ(3), QQ(1)]], (2, 2), QQ)
+    assert U == DDM([[QQ(1), QQ(2)], [QQ(0), QQ(-2)]], (2, 2), QQ)
+    assert swaps == []
+
+    A = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 1, 2]]
+    Lexp = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1]]
+    Uexp = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 0, 1]]
+    to_dom = lambda rows, dom: [[dom(e) for e in row] for row in rows]
+    A = DDM(to_dom(A, QQ), (4, 4), QQ)
+    Lexp = DDM(to_dom(Lexp, QQ), (4, 4), QQ)
+    Uexp = DDM(to_dom(Uexp, QQ), (4, 4), QQ)
+    L, U, swaps = A.lu()
+    assert L == Lexp
+    assert U == Uexp
+    assert swaps == []
+
+
+def test_DDM_lu_solve():
+    # Basic example
+    A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Example with swaps
+    A = DDM([[QQ(0), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    assert A.lu_solve(b) == x
+
+    # Overdetermined, consistent
+    A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Overdetermined, inconsistent
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(4)]], (3, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.lu_solve(b))
+
+    # Square, noninvertible
+    A = DDM([[QQ(1), QQ(2)], [QQ(1), QQ(2)]], (2, 2), QQ)
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.lu_solve(b))
+
+    # Underdetermined
+    A = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    b = DDM([[QQ(3)]], (1, 1), QQ)
+    raises(NotImplementedError, lambda: A.lu_solve(b))
+
+    # Domain mismatch
+    bz = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    raises(DMDomainError, lambda: A.lu_solve(bz))
+
+    # Shape mismatch
+    b3 = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    raises(DMShapeError, lambda: A.lu_solve(b3))
+
+
+def test_DDM_charpoly():
+    A = DDM([], (0, 0), ZZ)
+    assert A.charpoly() == [ZZ(1)]
+
+    A = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+    Avec = [ZZ(1), ZZ(-15), ZZ(-18), ZZ(0)]
+    assert A.charpoly() == Avec
+
+    A = DDM([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    raises(DMShapeError, lambda: A.charpoly())
+
+
+def test_DDM_getitem():
+    dm = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+
+    assert dm.getitem(1, 1) == ZZ(5)
+    assert dm.getitem(1, -2) == ZZ(5)
+    assert dm.getitem(-1, -3) == ZZ(7)
+
+    raises(IndexError, lambda: dm.getitem(3, 3))
+
+
+def test_DDM_setitem():
+    dm = DDM.zeros((3, 3), ZZ)
+    dm.setitem(0, 0, 1)
+    dm.setitem(1, -2, 1)
+    dm.setitem(-1, -1, 1)
+    assert dm == DDM.eye(3, ZZ)
+
+    raises(IndexError, lambda: dm.setitem(3, 3, 0))
+
+
+def test_DDM_extract_slice():
+    dm = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+
+    assert dm.extract_slice(slice(0, 3), slice(0, 3)) == dm
+    assert dm.extract_slice(slice(1, 3), slice(-2)) == DDM([[4], [7]], (2, 1), ZZ)
+    assert dm.extract_slice(slice(1, 3), slice(-2)) == DDM([[4], [7]], (2, 1), ZZ)
+    assert dm.extract_slice(slice(2, 3), slice(-2)) == DDM([[ZZ(7)]], (1, 1), ZZ)
+    assert dm.extract_slice(slice(0, 2), slice(-2)) == DDM([[1], [4]], (2, 1), ZZ)
+    assert dm.extract_slice(slice(-1), slice(-1)) == DDM([[1, 2], [4, 5]], (2, 2), ZZ)
+
+    assert dm.extract_slice(slice(2), slice(3, 4)) == DDM([[], []], (2, 0), ZZ)
+    assert dm.extract_slice(slice(3, 4), slice(2)) == DDM([], (0, 2), ZZ)
+    assert dm.extract_slice(slice(3, 4), slice(3, 4)) == DDM([], (0, 0), ZZ)
+
+
+def test_DDM_extract():
+    dm1 = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+    dm2 = DDM([
+        [ZZ(6), ZZ(4)],
+        [ZZ(3), ZZ(1)]], (2, 2), ZZ)
+    assert dm1.extract([1, 0], [2, 0]) == dm2
+    assert dm1.extract([-2, 0], [-1, 0]) == dm2
+
+    assert dm1.extract([], []) == DDM.zeros((0, 0), ZZ)
+    assert dm1.extract([1], []) == DDM.zeros((1, 0), ZZ)
+    assert dm1.extract([], [1]) == DDM.zeros((0, 1), ZZ)
+
+    raises(IndexError, lambda: dm2.extract([2], [0]))
+    raises(IndexError, lambda: dm2.extract([0], [2]))
+    raises(IndexError, lambda: dm2.extract([-3], [0]))
+    raises(IndexError, lambda: dm2.extract([0], [-3]))
+
+
+def test_DDM_flat():
+    dm = DDM([
+        [ZZ(6), ZZ(4)],
+        [ZZ(3), ZZ(1)]], (2, 2), ZZ)
+    assert dm.flat() == [ZZ(6), ZZ(4), ZZ(3), ZZ(1)]
+
+
+def test_DDM_is_zero_matrix():
+    A = DDM([[QQ(1), QQ(0)], [QQ(0), QQ(0)]], (2, 2), QQ)
+    Azero = DDM.zeros((1, 2), QQ)
+    assert A.is_zero_matrix() is False
+    assert Azero.is_zero_matrix() is True
+
+
+def test_DDM_is_upper():
+    # Wide matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(0), QQ(8), QQ(9)]
+    ], (3, 4), QQ)
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(7), QQ(8), QQ(9)]
+    ], (3, 4), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+    # Tall matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(0)]
+    ], (4, 3), QQ)
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(10)]
+    ], (4, 3), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+
+def test_DDM_is_lower():
+    # Tall matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(0), QQ(8), QQ(9)]
+    ], (3, 4), QQ).transpose()
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(7), QQ(8), QQ(9)]
+    ], (3, 4), QQ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False
+
+    # Wide matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(0)]
+    ], (4, 3), QQ).transpose()
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(10)]
+    ], (4, 3), QQ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_dense.py

@@ -0,0 +1,350 @@
+from sympy.testing.pytest import raises
+
+from sympy.polys import ZZ, QQ
+
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.dense import (
+        ddm_transpose,
+        ddm_iadd, ddm_isub, ddm_ineg, ddm_imatmul, ddm_imul, ddm_irref,
+        ddm_idet, ddm_iinv, ddm_ilu, ddm_ilu_split, ddm_ilu_solve, ddm_berk)
+
+from sympy.polys.matrices.exceptions import (
+    DMDomainError,
+    DMNonInvertibleMatrixError,
+    DMNonSquareMatrixError,
+    DMShapeError,
+)
+
+
+def test_ddm_transpose():
+    a = [[1, 2], [3, 4]]
+    assert ddm_transpose(a) == [[1, 3], [2, 4]]
+
+
+def test_ddm_iadd():
+    a = [[1, 2], [3, 4]]
+    b = [[5, 6], [7, 8]]
+    ddm_iadd(a, b)
+    assert a == [[6, 8], [10, 12]]
+
+
+def test_ddm_isub():
+    a = [[1, 2], [3, 4]]
+    b = [[5, 6], [7, 8]]
+    ddm_isub(a, b)
+    assert a == [[-4, -4], [-4, -4]]
+
+
+def test_ddm_ineg():
+    a = [[1, 2], [3, 4]]
+    ddm_ineg(a)
+    assert a == [[-1, -2], [-3, -4]]
+
+
+def test_ddm_matmul():
+    a = [[1, 2], [3, 4]]
+    ddm_imul(a, 2)
+    assert a == [[2, 4], [6, 8]]
+
+    a = [[1, 2], [3, 4]]
+    ddm_imul(a, 0)
+    assert a == [[0, 0], [0, 0]]
+
+
+def test_ddm_imatmul():
+    a = [[1, 2, 3], [4, 5, 6]]
+    b = [[1, 2], [3, 4], [5, 6]]
+
+    c1 = [[0, 0], [0, 0]]
+    ddm_imatmul(c1, a, b)
+    assert c1 == [[22, 28], [49, 64]]
+
+    c2 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+    ddm_imatmul(c2, b, a)
+    assert c2 == [[9, 12, 15], [19, 26, 33], [29, 40, 51]]
+
+    b3 = [[1], [2], [3]]
+    c3 = [[0], [0]]
+    ddm_imatmul(c3, a, b3)
+    assert c3 == [[14], [32]]
+
+
+def test_ddm_irref():
+    # Empty matrix
+    A = []
+    Ar = []
+    pivots = []
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # Standard square case
+    A = [[QQ(0), QQ(1)], [QQ(1), QQ(1)]]
+    Ar = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # m < n  case
+    A = [[QQ(1), QQ(2), QQ(1)], [QQ(3), QQ(4), QQ(1)]]
+    Ar = [[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # same m < n  but reversed
+    A = [[QQ(3), QQ(4), QQ(1)], [QQ(1), QQ(2), QQ(1)]]
+    Ar = [[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # m > n case
+    A = [[QQ(1), QQ(0)], [QQ(1), QQ(3)], [QQ(0), QQ(1)]]
+    Ar = [[QQ(1), QQ(0)], [QQ(0), QQ(1)], [QQ(0), QQ(0)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # Example with missing pivot
+    A = [[QQ(1), QQ(0), QQ(1)], [QQ(3), QQ(0), QQ(1)]]
+    Ar = [[QQ(1), QQ(0), QQ(0)], [QQ(0), QQ(0), QQ(1)]]
+    pivots = [0, 2]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # Example with missing pivot and no replacement
+    A = [[QQ(0), QQ(1)], [QQ(0), QQ(2)], [QQ(1), QQ(0)]]
+    Ar = [[QQ(1), QQ(0)], [QQ(0), QQ(1)], [QQ(0), QQ(0)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+
+def test_ddm_idet():
+    A = []
+    assert ddm_idet(A, ZZ) == ZZ(1)
+
+    A = [[ZZ(2)]]
+    assert ddm_idet(A, ZZ) == ZZ(2)
+
+    A = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    assert ddm_idet(A, ZZ) == ZZ(-2)
+
+    A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(3), ZZ(5)]]
+    assert ddm_idet(A, ZZ) == ZZ(-1)
+
+    A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(2), ZZ(5)]]
+    assert ddm_idet(A, ZZ) == ZZ(0)
+
+    A = [[QQ(1, 2), QQ(1, 2)], [QQ(1, 3), QQ(1, 4)]]
+    assert ddm_idet(A, QQ) == QQ(-1, 24)
+
+
+def test_ddm_inv():
+    A = []
+    Ainv = []
+    ddm_iinv(Ainv, A, QQ)
+    assert Ainv == A
+
+    A = []
+    Ainv = []
+    raises(DMDomainError, lambda: ddm_iinv(Ainv, A, ZZ))
+
+    A = [[QQ(1), QQ(2)]]
+    Ainv = [[QQ(0), QQ(0)]]
+    raises(DMNonSquareMatrixError, lambda: ddm_iinv(Ainv, A, QQ))
+
+    A = [[QQ(1, 1), QQ(2, 1)], [QQ(3, 1), QQ(4, 1)]]
+    Ainv = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    Ainv_expected = [[QQ(-2, 1), QQ(1, 1)], [QQ(3, 2), QQ(-1, 2)]]
+    ddm_iinv(Ainv, A, QQ)
+    assert Ainv == Ainv_expected
+
+    A = [[QQ(1, 1), QQ(2, 1)], [QQ(2, 1), QQ(4, 1)]]
+    Ainv = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    raises(DMNonInvertibleMatrixError, lambda: ddm_iinv(Ainv, A, QQ))
+
+
+def test_ddm_ilu():
+    A = []
+    Alu = []
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[]]
+    Alu = [[]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    Alu = [[QQ(1), QQ(2)], [QQ(3), QQ(-2)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(0), QQ(2)], [QQ(3), QQ(4)]]
+    Alu = [[QQ(3), QQ(4)], [QQ(0), QQ(2)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == [(0, 1)]
+
+    A = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)], [QQ(7), QQ(8), QQ(9)]]
+    Alu = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(-3), QQ(-6)], [QQ(7), QQ(2), QQ(0)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(0), QQ(1), QQ(2)], [QQ(0), QQ(1), QQ(3)], [QQ(1), QQ(1), QQ(2)]]
+    Alu = [[QQ(1), QQ(1), QQ(2)], [QQ(0), QQ(1), QQ(3)], [QQ(0), QQ(1), QQ(-1)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == [(0, 2)]
+
+    A = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
+    Alu = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(-3), QQ(-6)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]]
+    Alu = [[QQ(1), QQ(2)], [QQ(3), QQ(-2)], [QQ(5), QQ(2)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+
+def test_ddm_ilu_split():
+    U = []
+    L = []
+    Uexp = []
+    Lexp = []
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[]]
+    L = [[QQ(1)]]
+    Uexp = [[]]
+    Lexp = [[QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    L = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    Uexp = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)]]
+    Lexp = [[QQ(1), QQ(0)], [QQ(3), QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
+    L = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    Uexp = [[QQ(1), QQ(2), QQ(3)], [QQ(0), QQ(-3), QQ(-6)]]
+    Lexp = [[QQ(1), QQ(0)], [QQ(4), QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]]
+    L = [[QQ(1), QQ(0), QQ(0)], [QQ(0), QQ(1), QQ(0)], [QQ(0), QQ(0), QQ(1)]]
+    Uexp = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)], [QQ(0), QQ(0)]]
+    Lexp = [[QQ(1), QQ(0), QQ(0)], [QQ(3), QQ(1), QQ(0)], [QQ(5), QQ(2), QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+
+def test_ddm_ilu_solve():
+    # Basic example
+    # A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    U = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)]]
+    L = [[QQ(1), QQ(0)], [QQ(3), QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(0)]], (2, 1), QQ)
+    xexp = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == xexp
+
+    # Example with swaps
+    # A = [[QQ(0), QQ(2)], [QQ(3), QQ(4)]]
+    U = [[QQ(3), QQ(4)], [QQ(0), QQ(2)]]
+    L = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    swaps = [(0, 1)]
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(0)]], (2, 1), QQ)
+    xexp = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == xexp
+
+    # Overdetermined, consistent
+    # A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    U = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)], [QQ(0), QQ(0)]]
+    L = [[QQ(1), QQ(0), QQ(0)], [QQ(3), QQ(1), QQ(0)], [QQ(5), QQ(2), QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(0)]], (2, 1), QQ)
+    xexp = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == xexp
+
+    # Overdetermined, inconsistent
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(4)]], (3, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Square, noninvertible
+    # A = DDM([[QQ(1), QQ(2)], [QQ(1), QQ(2)]], (2, 2), QQ)
+    U = [[QQ(1), QQ(2)], [QQ(0), QQ(0)]]
+    L = [[QQ(1), QQ(0)], [QQ(1), QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Underdetermined
+    # A = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    U = [[QQ(1), QQ(2)]]
+    L = [[QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(3)]], (1, 1), QQ)
+    raises(NotImplementedError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Shape mismatch
+    b3 = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    raises(DMShapeError, lambda: ddm_ilu_solve(x, L, U, swaps, b3))
+
+    # Empty shape mismatch
+    U = [[QQ(1)]]
+    L = [[QQ(1)]]
+    swaps = []
+    x = [[QQ(1)]]
+    b = []
+    raises(DMShapeError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Empty system
+    U = []
+    L = []
+    swaps = []
+    b = []
+    x = []
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == []
+
+
+def test_ddm_charpoly():
+    A = []
+    assert ddm_berk(A, ZZ) == [[ZZ(1)]]
+
+    A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]]
+    Avec = [[ZZ(1)], [ZZ(-15)], [ZZ(-18)], [ZZ(0)]]
+    assert ddm_berk(A, ZZ) == Avec
+
+    A = DDM([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    raises(DMShapeError, lambda: ddm_berk(A, ZZ))

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_domainscalar.py

@@ -0,0 +1,153 @@
+from sympy.testing.pytest import raises
+
+from sympy.core.symbol import S
+from sympy.polys import ZZ, QQ
+from sympy.polys.matrices.domainscalar import DomainScalar
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+
+def test_DomainScalar___new__():
+    raises(TypeError, lambda: DomainScalar(ZZ(1), QQ))
+    raises(TypeError, lambda: DomainScalar(ZZ(1), 1))
+
+
+def test_DomainScalar_new():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = A.new(ZZ(4), ZZ)
+    assert B == DomainScalar(ZZ(4), ZZ)
+
+
+def test_DomainScalar_repr():
+    A = DomainScalar(ZZ(1), ZZ)
+    assert repr(A) in {'1', 'mpz(1)'}
+
+
+def test_DomainScalar_from_sympy():
+    expr = S(1)
+    B = DomainScalar.from_sympy(expr)
+    assert B == DomainScalar(ZZ(1), ZZ)
+
+
+def test_DomainScalar_to_sympy():
+    B = DomainScalar(ZZ(1), ZZ)
+    expr = B.to_sympy()
+    assert expr.is_Integer and expr == 1
+
+
+def test_DomainScalar_to_domain():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = A.to_domain(QQ)
+    assert B == DomainScalar(QQ(1), QQ)
+
+
+def test_DomainScalar_convert_to():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = A.convert_to(QQ)
+    assert B == DomainScalar(QQ(1), QQ)
+
+
+def test_DomainScalar_unify():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    A, B = A.unify(B)
+    assert A.domain == B.domain == QQ
+
+
+def test_DomainScalar_add():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A + B == DomainScalar(QQ(3), QQ)
+
+    raises(TypeError, lambda: A + 1.5)
+
+def test_DomainScalar_sub():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A - B == DomainScalar(QQ(-1), QQ)
+
+    raises(TypeError, lambda: A - 1.5)
+
+def test_DomainScalar_mul():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    dm = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A * B == DomainScalar(QQ(2), QQ)
+    assert A * dm == dm
+    assert B * 2 == DomainScalar(QQ(4), QQ)
+
+    raises(TypeError, lambda: A * 1.5)
+
+
+def test_DomainScalar_floordiv():
+    A = DomainScalar(ZZ(-5), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A // B == DomainScalar(QQ(-5, 2), QQ)
+    C = DomainScalar(ZZ(2), ZZ)
+    assert A // C == DomainScalar(ZZ(-3), ZZ)
+
+    raises(TypeError, lambda: A // 1.5)
+
+
+def test_DomainScalar_mod():
+    A = DomainScalar(ZZ(5), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A % B == DomainScalar(QQ(0), QQ)
+    C = DomainScalar(ZZ(2), ZZ)
+    assert A % C == DomainScalar(ZZ(1), ZZ)
+
+    raises(TypeError, lambda: A % 1.5)
+
+
+def test_DomainScalar_divmod():
+    A = DomainScalar(ZZ(5), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert divmod(A, B) == (DomainScalar(QQ(5, 2), QQ), DomainScalar(QQ(0), QQ))
+    C = DomainScalar(ZZ(2), ZZ)
+    assert divmod(A, C) == (DomainScalar(ZZ(2), ZZ), DomainScalar(ZZ(1), ZZ))
+
+    raises(TypeError, lambda: divmod(A, 1.5))
+
+
+def test_DomainScalar_pow():
+    A = DomainScalar(ZZ(-5), ZZ)
+    B = A**(2)
+    assert B == DomainScalar(ZZ(25), ZZ)
+
+    raises(TypeError, lambda: A**(1.5))
+
+
+def test_DomainScalar_pos():
+    A = DomainScalar(QQ(2), QQ)
+    B = DomainScalar(QQ(2), QQ)
+    assert  +A == B
+
+
+def test_DomainScalar_neg():
+    A = DomainScalar(QQ(2), QQ)
+    B = DomainScalar(QQ(-2), QQ)
+    assert  -A == B
+
+
+def test_DomainScalar_eq():
+    A = DomainScalar(QQ(2), QQ)
+    assert A == A
+    B = DomainScalar(ZZ(-5), ZZ)
+    assert A != B
+    C = DomainScalar(ZZ(2), ZZ)
+    assert A != C
+    D = [1]
+    assert A != D
+
+
+def test_DomainScalar_isZero():
+    A = DomainScalar(ZZ(0), ZZ)
+    assert A.is_zero() == True
+    B = DomainScalar(ZZ(1), ZZ)
+    assert B.is_zero() == False
+
+
+def test_DomainScalar_isOne():
+    A = DomainScalar(ZZ(1), ZZ)
+    assert A.is_one() == True
+    B = DomainScalar(ZZ(0), ZZ)
+    assert B.is_one() == False

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_eigen.py

@@ -0,0 +1,90 @@
+"""
+Tests for the sympy.polys.matrices.eigen module
+"""
+
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+
+from sympy.polys.agca.extensions import FiniteExtension
+from sympy.polys.domains import QQ
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+from sympy.polys.matrices.eigen import dom_eigenvects, dom_eigenvects_to_sympy
+
+
+def test_dom_eigenvects_rational():
+    # Rational eigenvalues
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(1), QQ(2)]], (2, 2), QQ)
+    rational_eigenvects = [
+        (QQ, QQ(3), 1, DomainMatrix([[QQ(1), QQ(1)]], (1, 2), QQ)),
+        (QQ, QQ(0), 1, DomainMatrix([[QQ(-2), QQ(1)]], (1, 2), QQ)),
+    ]
+    assert dom_eigenvects(A) == (rational_eigenvects, [])
+
+    # Test converting to Expr:
+    sympy_eigenvects = [
+        (S(3), 1, [Matrix([1, 1])]),
+        (S(0), 1, [Matrix([-2, 1])]),
+    ]
+    assert dom_eigenvects_to_sympy(rational_eigenvects, [], Matrix) == sympy_eigenvects
+
+
+def test_dom_eigenvects_algebraic():
+    # Algebraic eigenvalues
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Avects = dom_eigenvects(A)
+
+    # Extract the dummy to build the expected result:
+    lamda = Avects[1][0][1].gens[0]
+    irreducible = Poly(lamda**2 - 5*lamda - 2, lamda, domain=QQ)
+    K = FiniteExtension(irreducible)
+    KK = K.from_sympy
+    algebraic_eigenvects = [
+        (K, irreducible, 1, DomainMatrix([[KK((lamda-4)/3), KK(1)]], (1, 2), K)),
+    ]
+    assert Avects == ([], algebraic_eigenvects)
+
+    # Test converting to Expr:
+    sympy_eigenvects = [
+        (S(5)/2 - sqrt(33)/2, 1, [Matrix([[-sqrt(33)/6 - S(1)/2], [1]])]),
+        (S(5)/2 + sqrt(33)/2, 1, [Matrix([[-S(1)/2 + sqrt(33)/6], [1]])]),
+    ]
+    assert dom_eigenvects_to_sympy([], algebraic_eigenvects, Matrix) == sympy_eigenvects
+
+
+def test_dom_eigenvects_rootof():
+    # Algebraic eigenvalues
+    A = DomainMatrix([
+        [0, 0, 0, 0, -1],
+        [1, 0, 0, 0, 1],
+        [0, 1, 0, 0, 0],
+        [0, 0, 1, 0, 0],
+        [0, 0, 0, 1, 0]], (5, 5), QQ)
+    Avects = dom_eigenvects(A)
+
+    # Extract the dummy to build the expected result:
+    lamda = Avects[1][0][1].gens[0]
+    irreducible = Poly(lamda**5 - lamda + 1, lamda, domain=QQ)
+    K = FiniteExtension(irreducible)
+    KK = K.from_sympy
+    algebraic_eigenvects = [
+        (K, irreducible, 1,
+            DomainMatrix([
+                [KK(lamda**4-1), KK(lamda**3), KK(lamda**2), KK(lamda), KK(1)]
+            ], (1, 5), K)),
+    ]
+    assert Avects == ([], algebraic_eigenvects)
+
+    # Test converting to Expr (slow):
+    l0, l1, l2, l3, l4 = [CRootOf(lamda**5 - lamda + 1, i) for i in range(5)]
+    sympy_eigenvects = [
+        (l0, 1, [Matrix([-1 + l0**4, l0**3, l0**2, l0, 1])]),
+        (l1, 1, [Matrix([-1 + l1**4, l1**3, l1**2, l1, 1])]),
+        (l2, 1, [Matrix([-1 + l2**4, l2**3, l2**2, l2, 1])]),
+        (l3, 1, [Matrix([-1 + l3**4, l3**3, l3**2, l3, 1])]),
+        (l4, 1, [Matrix([-1 + l4**4, l4**3, l4**2, l4, 1])]),
+    ]
+    assert dom_eigenvects_to_sympy([], algebraic_eigenvects, Matrix) == sympy_eigenvects

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_fflu.py

@@ -0,0 +1,301 @@
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.domains import ZZ, QQ
+from sympy import Matrix
+import pytest
+
+
+FFLU_EXAMPLES = [
+    (
+        'zz_2x3',
+        DM([[1, 2, 3], [4, 5, 6]], ZZ),
+        DM([[1, 0], [0, 1]], ZZ),
+        DM([[1, 0], [4, -3]], ZZ),
+        DM([[1, 0], [0, -3]], ZZ),
+        DM([[1, 2, 3], [0, -3, -6]], ZZ),
+    ),
+
+    (
+        'zz_2x2',
+        DM([[4, 3], [6, 3]], ZZ),
+        DM([[1, 0], [0, 1]], ZZ),
+        DM([[1, 0], [6, -6]], ZZ),
+        DM([[4, 0], [0, -3]], ZZ),
+        DM([[4, 3], [0, -3]], ZZ),
+    ),
+
+    (
+        'zz_3x2',
+        DM([[1, 2], [3, 4], [5, 6]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[1, 0, 0], [3, 1, 0], [5, 2, 1]], ZZ),
+        DM([[1, 0], [0, -2]], ZZ),
+        DM([[1, 2], [0, -2], [0, 0]], ZZ),
+    ),
+
+    (
+        'zz_3x3',
+        DM([[1, 2, 3], [4, 5, 6], [7, 8, 9]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[1, 0, 0], [4, 1, 0], [7, 2, 1]], ZZ),
+        DM([[1, 0, 0], [0, -3, 0], [0, 0, 0]], ZZ),
+        DM([[1, 2, 3], [0, -3, -6], [0, 0, 0]], ZZ),
+    ),
+
+    (
+        'zz_zero',
+        DM([[0, 0, 0], [0, 0, 0], [0, 0, 0]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[0, 0, 0], [0, 0, 0], [0, 0, 0]], ZZ),
+        DM([[0, 0, 0], [0, 0, 0], [0, 0, 0]], ZZ),
+    ),
+
+    (
+        'zz_empty',
+        DM([], ZZ),
+        DM([], ZZ),
+        DM([], ZZ),
+        DM([], ZZ),
+        DM([], ZZ),
+    ),
+
+    (
+        'zz_empty_0x2',
+        DomainMatrix([], (0, 2), ZZ),
+        DomainMatrix([], (0, 0), ZZ),
+        DomainMatrix([], (0, 0), ZZ),
+        DomainMatrix([], (0, 0), ZZ),
+        DomainMatrix([], (0, 2), ZZ)
+    ),
+
+    (
+
+        'zz_empty_2x0',
+        DomainMatrix([[], []], (2, 0), ZZ),
+        DomainMatrix.eye((2, 2), ZZ),
+        DomainMatrix.eye((2, 2), ZZ),
+        DomainMatrix.eye((2, 2), ZZ),
+        DomainMatrix([[], []], (2, 0), ZZ)
+
+    ),
+
+    (
+        'zz_negative',
+        DM([[-1, -2], [-3, -4]], ZZ),
+        DM([[1, 0], [0, 1]], ZZ),
+        DM([[-1, 0], [-3, -2]], ZZ),
+        DM([[-1, 0], [0, 2]], ZZ),
+        DM([[-1, -2], [0, -2]], ZZ),
+    ),
+
+    (
+        'zz_mixed_signs',
+        DM([[1, -2], [-3, 4]], ZZ),
+        DM([[1, 0], [0, 1]], ZZ),
+        DM([[1, 0], [-3, 1]], ZZ),
+        DM([[1, 0], [0, -2]], ZZ),
+        DM([[1, -2], [0, -2]], ZZ),
+    ),
+
+    (
+        'zz_upper_triangular',
+        DM([[1, 2, 3], [0, 4, 5], [0, 0, 6]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[1, 0, 0], [0, 4, 0], [0, 0, 24]], ZZ),
+        DM([[1, 0, 0], [0, 4, 0], [0, 0, 96]], ZZ),
+        DM([[1, 2, 3], [0, 4, 5], [0, 0, 24]], ZZ),
+    ),
+
+    (
+        'zz_lower_triangular',
+        DM([[1, 0, 0], [2, 3, 0], [4, 5, 6]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[1, 0, 0], [2, 3, 0], [4, 5, 18]], ZZ),
+        DM([[1, 0, 0], [0, 3, 0], [0, 0, 54]], ZZ),
+        DM([[1, 0, 0], [0, 3, 0], [0, 0, 18]], ZZ),
+    ),
+
+    (
+        'zz_diagonal',
+        DM([[2, 0, 0], [0, 3, 0], [0, 0, 4]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[2, 0, 0], [0, 6, 0], [0, 0, 24]], ZZ),
+        DM([[2, 0, 0], [0, 12, 0], [0, 0, 144]], ZZ),
+        DM([[2, 0, 0], [0, 6, 0], [0, 0, 24]], ZZ)
+
+    ),
+
+    (
+        'rank_deficient_3x3',
+        DM([[1, 2, 3], [2, 4, 6], [3, 6, 9]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[1, 0, 0], [2, 1, 0], [3, 0, 1]], ZZ),
+        DM([[1, 0, 0], [0, 0, 0], [0, 0, 0]], ZZ),
+        DM([[1, 2, 3], [0, 0, 0], [0, 0, 0]], ZZ),
+    ),
+
+    (
+        'zz_1x1',
+        DM([[5]], ZZ),
+        DM([[1]], ZZ),
+        DM([[5]], ZZ),
+        DM([[5]], ZZ),
+        DM([[5]], ZZ),
+    ),
+
+    (
+        'zz_nx1_2rows',
+        DM([[81], [54]], ZZ),
+        DM([[1, 0], [0, 1]], ZZ),
+        DM([[81, 0], [54, 81]], ZZ),
+        DM([[81, 0], [0, 81]], ZZ),
+        DM([[81], [0]], ZZ),
+    ),
+
+    (
+        'zz_nx2_3rows',
+        DM([[2, 7], [7, 45], [25, 84]], ZZ),
+        DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]], ZZ),
+        DM([[2, 0, 0], [7, 82, 0], [25, 41, 41]], ZZ),
+        DM([[2, 0, 0], [0, 82, 0], [0, 0, 41]], ZZ),
+        DM([[2, 7], [0, 82], [0, 0]], ZZ),
+    ),
+
+    (
+
+        'zz_1x2',
+        DM([[0, 28]], ZZ),
+        DM([[1]], ZZ),
+        DM([[28]], ZZ),
+        DM([[28]], ZZ),
+        DM([[0, 28]], ZZ)
+    ),
+
+    (
+        'zz_nx3_4rows',
+        DM([[84, 30, 9], [20, 59, 13], [53, 46, 81], [63, 48, 29]], ZZ),
+        DM([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], ZZ),
+        DM([[84, 0, 0, 0], [20, 365904, 0, 0], [53, 303411, 303411, 0], [63, 303411, 303411, 303411]], ZZ),
+        DM([[84, 0, 0, 0], [0, 365904, 0, 0], [0, 0, 1321658316, 0], [0, 0, 0, 303411]], ZZ),
+        DM([[84, 30, 9], [0, 365904, 13], [0, 0, 1321658316], [0, 0, 0]], ZZ),
+    ),
+
+    (
+        'fflu_row_swap',
+        DM([[0, 1, 2], [3, 4, 5], [6, 7, 8]], ZZ),
+        DM([[0, 1, 0], [1, 0, 0], [0, 0, 1]], ZZ),
+        DM([[3, 0, 0], [0, 3, 0], [6, -3, 1]], ZZ),
+        DM([[3, 0, 0], [0, 9, 0], [0, 0, 3]], ZZ),
+        DM([[3, 4, 5], [0, 3, 6], [0, 0, 0]], ZZ)
+    ),
+]
+
+
+def _check_fflu(A, P, L, D, U):
+    P_field = P.to_field().to_dense()
+    L_field = L.to_field().to_dense()
+    D_field = D.to_field().to_dense()
+    U_field = U.to_field().to_dense()
+    m, n = A.shape
+    assert P_field.shape == (m, m)
+    assert L_field.shape == (m, m)
+    assert D_field.shape == (m, m)
+    assert U_field.shape == (m, n)
+    assert L_field.is_lower
+    assert D_field.is_diagonal
+    di, d = D.inv_den()
+    assert P.matmul(A).rmul(d) == L.matmul(di).matmul(U)
+    assert U_field.is_upper
+
+
+def _to_DM(A, ans):
+    if isinstance(A, DomainMatrix):
+        return A
+    elif isinstance(A, Matrix):
+        return A.to_DM(ans.domain)
+    return DomainMatrix(A.to_list(), A.shape, A.domain)
+
+
+def _check_fflu_result(result, A, P_ans, L_ans, D_ans, U_ans):
+    P, L, D, U = result
+    P = _to_DM(P, P_ans)
+    L = _to_DM(L, L_ans)
+    D = _to_DM(D, D_ans)
+    U = _to_DM(U, U_ans)
+    A = _to_DM(A, P_ans)
+    m, n = A.shape
+    assert P.shape == (m, m)
+    assert L.shape == (m, m)
+    assert D.shape == (m, m)
+    assert U.shape == (m, n)
+    assert L.is_lower
+    assert D.is_diagonal
+    di, d = D.inv_den()
+    assert P.matmul(A).rmul(d) == L.matmul(di).matmul(U)
+    assert U.is_upper
+
+
+@pytest.mark.parametrize('name, A, P_ans, L_ans, D_ans, U_ans', FFLU_EXAMPLES)
+def test_dm_dense_fflu(name, A, P_ans, L_ans, D_ans, U_ans):
+    A = A.to_dense()
+    _check_fflu_result(A.fflu(), A, P_ans, L_ans, D_ans, U_ans)
+
+
+@pytest.mark.parametrize('name, A, P_ans, L_ans, D_ans, U_ans', FFLU_EXAMPLES)
+def test_dm_sparse_fflu(name, A, P_ans, L_ans, D_ans, U_ans):
+    A = A.to_sparse()
+    _check_fflu_result(A.fflu(), A, P_ans, L_ans, D_ans, U_ans)
+
+
+@pytest.mark.parametrize('name, A, P_ans, L_ans, D_ans, U_ans', FFLU_EXAMPLES)
+def test_ddm_fflu(name, A, P_ans, L_ans, D_ans, U_ans):
+    A = A.to_ddm()
+    _check_fflu_result(A.fflu(), A, P_ans, L_ans, D_ans, U_ans)
+
+
+@pytest.mark.parametrize('name, A, P_ans, L_ans, D_ans, U_ans', FFLU_EXAMPLES)
+def test_sdm_fflu(name, A, P_ans, L_ans, D_ans, U_ans):
+    A = A.to_sdm()
+    _check_fflu_result(A.fflu(), A, P_ans, L_ans, D_ans, U_ans)
+
+
+@pytest.mark.parametrize('name, A, P_ans, L_ans, D_ans, U_ans', FFLU_EXAMPLES)
+def test_dfm_fflu(name, A, P_ans, L_ans, D_ans, U_ans):
+    pytest.importorskip('flint')
+    if A.domain not in (ZZ, QQ) and not A.domain.is_FF:
+        pytest.skip("Domain not supported by DFM")
+    A = A.to_dfm()
+    _check_fflu_result(A.fflu(), A, P_ans, L_ans, D_ans, U_ans)
+
+
+def test_fflu_empty_matrix():
+    A = DomainMatrix([], (0, 0), ZZ)
+    P, L, D, U = A.fflu()
+    assert P.shape == (0, 0)
+    assert L.shape == (0, 0)
+    assert D.shape == (0, 0)
+    assert U.shape == (0, 0)
+
+
+def test_fflu_properties():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    P, L, D, U = A.fflu()
+    assert P.shape == (2, 2)
+    assert L.shape == (2, 2)
+    assert D.shape == (2, 2)
+    assert U.shape == (2, 2)
+    assert L.is_lower
+    assert U.is_upper
+    assert D.is_diagonal
+    di, d = D.inv_den()
+    assert P.matmul(A).rmul(d) == L.matmul(di).matmul(U)
+
+
+def test_fflu_rank_deficient():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(2), ZZ(4)]], (2, 2), ZZ)
+    P, L, D, U = A.fflu()
+    assert P.shape == (2, 2)
+    assert L.shape == (2, 2)
+    assert D.shape == (2, 2)
+    assert U.shape == (2, 2)
+    assert U.getitem_sympy(1, 1) == 0

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_inverse.py

@@ -0,0 +1,193 @@
+from sympy import ZZ, Matrix
+from sympy.polys.matrices import DM, DomainMatrix
+from sympy.polys.matrices.dense import ddm_iinv
+from sympy.polys.matrices.exceptions import DMNonInvertibleMatrixError
+from sympy.matrices.exceptions import NonInvertibleMatrixError
+
+import pytest
+from sympy.testing.pytest import raises
+from sympy.core.numbers import all_close
+
+from sympy.abc import x
+
+
+# Examples are given as adjugate matrix and determinant adj_det should match
+# these exactly but inv_den only matches after cancel_denom.
+
+
+INVERSE_EXAMPLES = [
+
+    (
+        'zz_1',
+        DomainMatrix([], (0, 0), ZZ),
+        DomainMatrix([], (0, 0), ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_2',
+        DM([[2]], ZZ),
+        DM([[1]], ZZ),
+        ZZ(2),
+    ),
+
+    (
+        'zz_3',
+        DM([[2, 0],
+            [0, 2]], ZZ),
+        DM([[2, 0],
+            [0, 2]], ZZ),
+        ZZ(4),
+    ),
+
+    (
+        'zz_4',
+        DM([[1, 2],
+            [3, 4]], ZZ),
+        DM([[ 4, -2],
+            [-3,  1]], ZZ),
+        ZZ(-2),
+    ),
+
+    (
+        'zz_5',
+        DM([[2, 2, 0],
+            [0, 2, 2],
+            [0, 0, 2]], ZZ),
+        DM([[4, -4, 4],
+            [0, 4, -4],
+            [0, 0,  4]], ZZ),
+        ZZ(8),
+    ),
+
+    (
+        'zz_6',
+        DM([[1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9]], ZZ),
+        DM([[-3,   6, -3],
+            [ 6, -12,  6],
+            [-3,   6, -3]], ZZ),
+        ZZ(0),
+    ),
+]
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_Matrix_inv(name, A, A_inv, den):
+
+    def _check(**kwargs):
+        if den != 0:
+            assert A.inv(**kwargs) == A_inv
+        else:
+            raises(NonInvertibleMatrixError, lambda: A.inv(**kwargs))
+
+    K = A.domain
+    A = A.to_Matrix()
+    A_inv = A_inv.to_Matrix() / K.to_sympy(den)
+    _check()
+    for method in ['GE', 'LU', 'ADJ', 'CH', 'LDL', 'QR']:
+        _check(method=method)
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dm_inv_den(name, A, A_inv, den):
+    if den != 0:
+        A_inv_f, den_f = A.inv_den()
+        assert A_inv_f.cancel_denom(den_f) == A_inv.cancel_denom(den)
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv_den())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dm_inv(name, A, A_inv, den):
+    A = A.to_field()
+    if den != 0:
+        A_inv = A_inv.to_field() / den
+        assert A.inv() == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_ddm_inv(name, A, A_inv, den):
+    A = A.to_field().to_ddm()
+    if den != 0:
+        A_inv = (A_inv.to_field() / den).to_ddm()
+        assert A.inv() == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_sdm_inv(name, A, A_inv, den):
+    A = A.to_field().to_sdm()
+    if den != 0:
+        A_inv = (A_inv.to_field() / den).to_sdm()
+        assert A.inv() == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dense_ddm_iinv(name, A, A_inv, den):
+    A = A.to_field().to_ddm().copy()
+    K = A.domain
+    A_result = A.copy()
+    if den != 0:
+        A_inv = (A_inv.to_field() / den).to_ddm()
+        ddm_iinv(A_result, A, K)
+        assert A_result == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: ddm_iinv(A_result, A, K))
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_Matrix_adjugate(name, A, A_inv, den):
+    A = A.to_Matrix()
+    A_inv = A_inv.to_Matrix()
+    assert A.adjugate() == A_inv
+    for method in ["bareiss", "berkowitz", "bird", "laplace", "lu"]:
+        assert A.adjugate(method=method) == A_inv
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dm_adj_det(name, A, A_inv, den):
+    assert A.adj_det() == (A_inv, den)
+
+
+def test_inverse_inexact():
+
+    M = Matrix([[x-0.3, -0.06, -0.22],
+                [-0.46, x-0.48, -0.41],
+                [-0.14, -0.39, x-0.64]])
+
+    Mn = Matrix([[1.0*x**2 - 1.12*x + 0.1473, 0.06*x + 0.0474, 0.22*x - 0.081],
+                 [0.46*x - 0.237, 1.0*x**2 - 0.94*x + 0.1612, 0.41*x - 0.0218],
+                 [0.14*x + 0.1122, 0.39*x - 0.1086, 1.0*x**2 - 0.78*x + 0.1164]])
+
+    d = 1.0*x**3 - 1.42*x**2 + 0.4249*x - 0.0546540000000002
+
+    Mi = Mn / d
+
+    M_dm = M.to_DM()
+    M_dmd = M_dm.to_dense()
+    M_dm_num, M_dm_den = M_dm.inv_den()
+    M_dmd_num, M_dmd_den = M_dmd.inv_den()
+
+    # XXX: We don't check M_dm().to_field().inv() which currently uses division
+    # and produces a more complicate result from gcd cancellation failing.
+    # DomainMatrix.inv() over RR(x) should be changed to clear denominators and
+    # use DomainMatrix.inv_den().
+
+    Minvs = [
+        M.inv(),
+        (M_dm_num.to_field() / M_dm_den).to_Matrix(),
+        (M_dmd_num.to_field() / M_dmd_den).to_Matrix(),
+        M_dm_num.to_Matrix() / M_dm_den.as_expr(),
+        M_dmd_num.to_Matrix() / M_dmd_den.as_expr(),
+    ]
+
+    for Minv in Minvs:
+        for Mi1, Mi2 in zip(Minv.flat(), Mi.flat()):
+            assert all_close(Mi2, Mi1)

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_linsolve.py

@@ -0,0 +1,112 @@
+#
+# test_linsolve.py
+#
+#    Test the internal implementation of linsolve.
+#
+
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.abc import x, y, z
+
+from sympy.polys.matrices.linsolve import _linsolve
+from sympy.polys.solvers import PolyNonlinearError
+
+
+def test__linsolve():
+    assert _linsolve([], [x]) == {x:x}
+    assert _linsolve([S.Zero], [x]) == {x:x}
+    assert _linsolve([x-1,x-2], [x]) is None
+    assert _linsolve([x-1], [x]) == {x:1}
+    assert _linsolve([x-1, y], [x, y]) == {x:1, y:S.Zero}
+    assert _linsolve([2*I], [x]) is None
+    raises(PolyNonlinearError, lambda: _linsolve([x*(1 + x)], [x]))
+
+
+def test__linsolve_float():
+
+    # This should give the exact answer:
+    eqs = [
+        y - x,
+        y - 0.0216 * x
+    ]
+    # Should _linsolve return floats here?
+    sol = {x:0, y:0}
+    assert _linsolve(eqs, (x, y)) == sol
+
+    # Other cases should be close to eps
+
+    def all_close(sol1, sol2, eps=1e-15):
+        close = lambda a, b: abs(a - b) < eps
+        assert sol1.keys() == sol2.keys()
+        return all(close(sol1[s], sol2[s]) for s in sol1)
+
+    eqs = [
+        0.8*x +         0.8*z + 0.2,
+        0.9*x + 0.7*y + 0.2*z + 0.9,
+        0.7*x + 0.2*y + 0.2*z + 0.5
+    ]
+    sol_exact = {x:-29/42, y:-11/21, z:37/84}
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    eqs = [
+        0.9*x + 0.3*y + 0.4*z + 0.6,
+        0.6*x + 0.9*y + 0.1*z + 0.7,
+        0.4*x + 0.6*y + 0.9*z + 0.5
+    ]
+    sol_exact = {x:-88/175, y:-46/105, z:-1/25}
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    eqs = [
+        0.4*x + 0.3*y + 0.6*z + 0.7,
+        0.4*x + 0.3*y + 0.9*z + 0.9,
+        0.7*x + 0.9*y,
+    ]
+    sol_exact = {x:-9/5, y:7/5, z:-2/3}
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    eqs = [
+        x*(0.7 + 0.6*I) + y*(0.4 + 0.7*I) + z*(0.9 + 0.1*I) + 0.5,
+        0.2*I*x + 0.2*I*y + z*(0.9 + 0.2*I) + 0.1,
+        x*(0.9 + 0.7*I) + y*(0.9 + 0.7*I) + z*(0.9 + 0.4*I) + 0.4,
+    ]
+    sol_exact = {
+        x:-6157/7995 - 411/5330*I,
+        y:8519/15990 + 1784/7995*I,
+        z:-34/533 + 107/1599*I,
+    }
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    # XXX: This system for x and y over RR(z) is problematic.
+    #
+    # eqs = [
+    #     x*(0.2*z + 0.9) + y*(0.5*z + 0.8) + 0.6,
+    #     0.1*x*z + y*(0.1*z + 0.6) + 0.9,
+    # ]
+    #
+    # linsolve(eqs, [x, y])
+    # The solution for x comes out as
+    #
+    #       -3.9e-5*z**2 - 3.6e-5*z - 8.67361737988404e-20
+    #  x =  ----------------------------------------------
+    #           3.0e-6*z**3 - 1.3e-5*z**2 - 5.4e-5*z
+    #
+    # The 8e-20 in the numerator should be zero which would allow z to cancel
+    # from top and bottom. It should be possible to avoid this somehow because
+    # the inverse of the matrix only has a quadratic factor (the determinant)
+    # in the denominator.
+
+
+def test__linsolve_deprecated():
+    raises(PolyNonlinearError, lambda:
+        _linsolve([Eq(x**2, x**2 + y)], [x, y]))
+    raises(PolyNonlinearError, lambda:
+        _linsolve([(x + y)**2 - x**2], [x]))
+    raises(PolyNonlinearError, lambda:
+        _linsolve([Eq((x + y)**2, x**2)], [x]))

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_lll.py

@@ -0,0 +1,145 @@
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices import DM
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+from sympy.polys.matrices.exceptions import DMRankError, DMValueError, DMShapeError, DMDomainError
+from sympy.polys.matrices.lll import _ddm_lll, ddm_lll, ddm_lll_transform
+from sympy.testing.pytest import raises
+
+
+def test_lll():
+    normal_test_data = [
+        (
+            DM([[1, 0, 0, 0, -20160],
+                [0, 1, 0, 0, 33768],
+                [0, 0, 1, 0, 39578],
+                [0, 0, 0, 1, 47757]], ZZ),
+            DM([[10, -3, -2, 8, -4],
+                [3, -9, 8, 1, -11],
+                [-3, 13, -9, -3, -9],
+                [-12, -7, -11, 9, -1]], ZZ)
+        ),
+        (
+            DM([[20, 52, 3456],
+                [14, 31, -1],
+                [34, -442, 0]], ZZ),
+            DM([[14, 31, -1],
+                [188, -101, -11],
+                [236, 13, 3443]], ZZ)
+        ),
+        (
+            DM([[34, -1, -86, 12],
+                [-54, 34, 55, 678],
+                [23, 3498, 234, 6783],
+                [87, 49, 665, 11]], ZZ),
+            DM([[34, -1, -86, 12],
+                [291, 43, 149, 83],
+                [-54, 34, 55, 678],
+                [-189, 3077, -184, -223]], ZZ)
+        )
+    ]
+    delta = QQ(5, 6)
+    for basis_dm, reduced_dm in normal_test_data:
+        reduced = _ddm_lll(basis_dm.rep.to_ddm(), delta=delta)[0]
+        assert reduced == reduced_dm.rep.to_ddm()
+
+        reduced = ddm_lll(basis_dm.rep.to_ddm(), delta=delta)
+        assert reduced == reduced_dm.rep.to_ddm()
+
+        reduced, transform = _ddm_lll(basis_dm.rep.to_ddm(), delta=delta, return_transform=True)
+        assert reduced == reduced_dm.rep.to_ddm()
+        assert transform.matmul(basis_dm.rep.to_ddm()) == reduced_dm.rep.to_ddm()
+
+        reduced, transform = ddm_lll_transform(basis_dm.rep.to_ddm(), delta=delta)
+        assert reduced == reduced_dm.rep.to_ddm()
+        assert transform.matmul(basis_dm.rep.to_ddm()) == reduced_dm.rep.to_ddm()
+
+        reduced = basis_dm.rep.lll(delta=delta)
+        assert reduced == reduced_dm.rep
+
+        reduced, transform = basis_dm.rep.lll_transform(delta=delta)
+        assert reduced == reduced_dm.rep
+        assert transform.matmul(basis_dm.rep) == reduced_dm.rep
+
+        reduced = basis_dm.rep.to_sdm().lll(delta=delta)
+        assert reduced == reduced_dm.rep.to_sdm()
+
+        reduced, transform = basis_dm.rep.to_sdm().lll_transform(delta=delta)
+        assert reduced == reduced_dm.rep.to_sdm()
+        assert transform.matmul(basis_dm.rep.to_sdm()) == reduced_dm.rep.to_sdm()
+
+        reduced = basis_dm.lll(delta=delta)
+        assert reduced == reduced_dm
+
+        reduced, transform = basis_dm.lll_transform(delta=delta)
+        assert reduced == reduced_dm
+        assert transform.matmul(basis_dm) == reduced_dm
+
+
+def test_lll_linear_dependent():
+    linear_dependent_test_data = [
+        DM([[0, -1, -2, -3],
+            [1, 0, -1, -2],
+            [2, 1, 0, -1],
+            [3, 2, 1, 0]], ZZ),
+        DM([[1, 0, 0, 1],
+            [0, 1, 0, 1],
+            [0, 0, 1, 1],
+            [1, 2, 3, 6]], ZZ),
+        DM([[3, -5, 1],
+            [4, 6, 0],
+            [10, -4, 2]], ZZ)
+    ]
+    for not_basis in linear_dependent_test_data:
+        raises(DMRankError, lambda: _ddm_lll(not_basis.rep.to_ddm()))
+        raises(DMRankError, lambda: ddm_lll(not_basis.rep.to_ddm()))
+        raises(DMRankError, lambda: not_basis.rep.lll())
+        raises(DMRankError, lambda: not_basis.rep.to_sdm().lll())
+        raises(DMRankError, lambda: not_basis.lll())
+        raises(DMRankError, lambda: _ddm_lll(not_basis.rep.to_ddm(), return_transform=True))
+        raises(DMRankError, lambda: ddm_lll_transform(not_basis.rep.to_ddm()))
+        raises(DMRankError, lambda: not_basis.rep.lll_transform())
+        raises(DMRankError, lambda: not_basis.rep.to_sdm().lll_transform())
+        raises(DMRankError, lambda: not_basis.lll_transform())
+
+
+def test_lll_wrong_delta():
+    dummy_matrix = DomainMatrix.ones((3, 3), ZZ)
+    for wrong_delta in [QQ(-1, 4), QQ(0, 1), QQ(1, 4), QQ(1, 1), QQ(100, 1)]:
+        raises(DMValueError, lambda: _ddm_lll(dummy_matrix.rep, delta=wrong_delta))
+        raises(DMValueError, lambda: ddm_lll(dummy_matrix.rep, delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.lll(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.to_sdm().lll(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.lll(delta=wrong_delta))
+        raises(DMValueError, lambda: _ddm_lll(dummy_matrix.rep, delta=wrong_delta, return_transform=True))
+        raises(DMValueError, lambda: ddm_lll_transform(dummy_matrix.rep, delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.lll_transform(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.to_sdm().lll_transform(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.lll_transform(delta=wrong_delta))
+
+
+def test_lll_wrong_shape():
+    wrong_shape_matrix = DomainMatrix.ones((4, 3), ZZ)
+    raises(DMShapeError, lambda: _ddm_lll(wrong_shape_matrix.rep))
+    raises(DMShapeError, lambda: ddm_lll(wrong_shape_matrix.rep))
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.lll())
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.to_sdm().lll())
+    raises(DMShapeError, lambda: wrong_shape_matrix.lll())
+    raises(DMShapeError, lambda: _ddm_lll(wrong_shape_matrix.rep, return_transform=True))
+    raises(DMShapeError, lambda: ddm_lll_transform(wrong_shape_matrix.rep))
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.lll_transform())
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.to_sdm().lll_transform())
+    raises(DMShapeError, lambda: wrong_shape_matrix.lll_transform())
+
+
+def test_lll_wrong_domain():
+    wrong_domain_matrix = DomainMatrix.ones((3, 3), QQ)
+    raises(DMDomainError, lambda: _ddm_lll(wrong_domain_matrix.rep))
+    raises(DMDomainError, lambda: ddm_lll(wrong_domain_matrix.rep))
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.lll())
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.to_sdm().lll())
+    raises(DMDomainError, lambda: wrong_domain_matrix.lll())
+    raises(DMDomainError, lambda: _ddm_lll(wrong_domain_matrix.rep, return_transform=True))
+    raises(DMDomainError, lambda: ddm_lll_transform(wrong_domain_matrix.rep))
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.lll_transform())
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.to_sdm().lll_transform())
+    raises(DMDomainError, lambda: wrong_domain_matrix.lll_transform())

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_normalforms.py

@@ -0,0 +1,156 @@
+from sympy.testing.pytest import raises
+
+from sympy.core.symbol import Symbol
+from sympy.polys.matrices.normalforms import (
+    invariant_factors,
+    smith_normal_form,
+    smith_normal_decomp,
+    is_smith_normal_form,
+    hermite_normal_form,
+    _hermite_normal_form,
+    _hermite_normal_form_modulo_D
+)
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.matrices.exceptions import DMDomainError, DMShapeError
+
+
+def test_is_smith_normal_form():
+
+    snf_examples = [
+        DM([[0, 0], [0, 0]], ZZ),
+        DM([[1, 0], [0, 0]], ZZ),
+        DM([[1, 0], [0, 1]], ZZ),
+        DM([[1, 0], [0, 2]], ZZ),
+    ]
+
+    non_snf_examples = [
+        DM([[0, 1], [0, 0]], ZZ),
+        DM([[0, 0], [0, 1]], ZZ),
+        DM([[2, 0], [0, 3]], ZZ),
+    ]
+
+    for m in snf_examples:
+        assert is_smith_normal_form(m) is True
+
+    for m in non_snf_examples:
+        assert is_smith_normal_form(m) is False
+
+
+def test_smith_normal():
+
+    m = DM([
+        [12, 6, 4, 8],
+        [3, 9, 6, 12],
+        [2, 16, 14, 28],
+        [20, 10, 10, 20]], ZZ)
+
+    smf = DM([
+        [1, 0, 0, 0],
+        [0, 10, 0, 0],
+        [0, 0, 30, 0],
+        [0, 0, 0, 0]], ZZ)
+
+    s = DM([
+        [0, 1, -1, 0],
+        [1, -4, 0, 0],
+        [0, -2, 3, 0],
+        [-2, 2, -1, 1]], ZZ)
+
+    t = DM([
+        [1, 1, 10, 0],
+        [0, -1, -2, 0],
+        [0, 1, 3, -2],
+        [0, 0, 0, 1]], ZZ)
+
+    assert smith_normal_form(m).to_dense() == smf
+    assert smith_normal_decomp(m) == (smf, s, t)
+    assert is_smith_normal_form(smf)
+    assert smf == s * m * t
+
+    m00 = DomainMatrix.zeros((0, 0), ZZ).to_dense()
+    m01 = DomainMatrix.zeros((0, 1), ZZ).to_dense()
+    m10 = DomainMatrix.zeros((1, 0), ZZ).to_dense()
+    i11 = DM([[1]], ZZ)
+
+    assert smith_normal_form(m00) == m00.to_sparse()
+    assert smith_normal_form(m01) == m01.to_sparse()
+    assert smith_normal_form(m10) == m10.to_sparse()
+    assert smith_normal_form(i11) == i11.to_sparse()
+
+    assert smith_normal_decomp(m00) == (m00, m00, m00)
+    assert smith_normal_decomp(m01) == (m01, m00, i11)
+    assert smith_normal_decomp(m10) == (m10, i11, m00)
+    assert smith_normal_decomp(i11) == (i11, i11, i11)
+
+    x = Symbol('x')
+    m = DM([[x-1,  1, -1],
+            [  0,  x, -1],
+            [  0, -1,  x]], QQ[x])
+    dx = m.domain.gens[0]
+    assert invariant_factors(m) == (1, dx-1, dx**2-1)
+
+    zr = DomainMatrix([], (0, 2), ZZ)
+    zc = DomainMatrix([[], []], (2, 0), ZZ)
+    assert smith_normal_form(zr).to_dense() == zr
+    assert smith_normal_form(zc).to_dense() == zc
+
+    assert smith_normal_form(DM([[2, 4]], ZZ)).to_dense() == DM([[2, 0]], ZZ)
+    assert smith_normal_form(DM([[0, -2]], ZZ)).to_dense() == DM([[2, 0]], ZZ)
+    assert smith_normal_form(DM([[0], [-2]], ZZ)).to_dense() == DM([[2], [0]], ZZ)
+
+    assert smith_normal_decomp(DM([[0, -2]], ZZ)) == (
+        DM([[2, 0]], ZZ), DM([[-1]], ZZ), DM([[0, 1], [1, 0]], ZZ)
+    )
+    assert smith_normal_decomp(DM([[0], [-2]], ZZ)) == (
+        DM([[2], [0]], ZZ), DM([[0, -1], [1, 0]], ZZ), DM([[1]], ZZ)
+    )
+
+    m =   DM([[3, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0]], ZZ)
+    snf = DM([[1, 0, 0, 0], [0, 6, 0, 0], [0, 0, 0, 0]], ZZ)
+    s = DM([[1, 0, 1], [2, 0, 3], [0, 1, 0]], ZZ)
+    t = DM([[1, -2, 0, 0], [0, 0, 0, 1], [-1, 3, 0, 0], [0, 0, 1, 0]], ZZ)
+
+    assert smith_normal_form(m).to_dense() == snf
+    assert smith_normal_decomp(m) == (snf, s, t)
+    assert is_smith_normal_form(snf)
+    assert snf == s * m * t
+
+    raises(ValueError, lambda: smith_normal_form(DM([[1]], ZZ[x])))
+
+
+def test_hermite_normal():
+    m = DM([[2, 7, 17, 29, 41], [3, 11, 19, 31, 43], [5, 13, 23, 37, 47]], ZZ)
+    hnf = DM([[1, 0, 0], [0, 2, 1], [0, 0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+    assert hermite_normal_form(m, D=ZZ(2)) == hnf
+    assert hermite_normal_form(m, D=ZZ(2), check_rank=True) == hnf
+
+    m = m.transpose()
+    hnf = DM([[37, 0, 19], [222, -6, 113], [48, 0, 25], [0, 2, 1], [0, 0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+    raises(DMShapeError, lambda: _hermite_normal_form_modulo_D(m, ZZ(96)))
+    raises(DMDomainError, lambda: _hermite_normal_form_modulo_D(m, QQ(96)))
+
+    m = DM([[8, 28, 68, 116, 164], [3, 11, 19, 31, 43], [5, 13, 23, 37, 47]], ZZ)
+    hnf = DM([[4, 0, 0], [0, 2, 1], [0, 0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+    assert hermite_normal_form(m, D=ZZ(8)) == hnf
+    assert hermite_normal_form(m, D=ZZ(8), check_rank=True) == hnf
+
+    m = DM([[10, 8, 6, 30, 2], [45, 36, 27, 18, 9], [5, 4, 3, 2, 1]], ZZ)
+    hnf = DM([[26, 2], [0, 9], [0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+
+    m = DM([[2, 7], [0, 0], [0, 0]], ZZ)
+    hnf = DM([[1], [0], [0]], ZZ)
+    assert hermite_normal_form(m) == hnf
+
+    m = DM([[-2, 1], [0, 1]], ZZ)
+    hnf = DM([[2, 1], [0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+
+    m = DomainMatrix([[QQ(1)]], (1, 1), QQ)
+    raises(DMDomainError, lambda: hermite_normal_form(m))
+    raises(DMDomainError, lambda: _hermite_normal_form(m))
+    raises(DMDomainError, lambda: _hermite_normal_form_modulo_D(m, ZZ(1)))

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_nullspace.py

@@ -0,0 +1,209 @@
+from sympy import ZZ, Matrix
+from sympy.polys.matrices import DM, DomainMatrix
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.sdm import SDM
+
+import pytest
+
+zeros = lambda shape, K: DomainMatrix.zeros(shape, K).to_dense()
+eye = lambda n, K: DomainMatrix.eye(n, K).to_dense()
+
+
+#
+# DomainMatrix.nullspace can have a divided answer or can return an undivided
+# uncanonical answer. The uncanonical answer is not unique but we can make it
+# unique by making it primitive (remove gcd). The tests here all show the
+# primitive form. We test two things:
+#
+#   A.nullspace().primitive()[1] == answer.
+#   A.nullspace(divide_last=True) == _divide_last(answer).
+#
+# The nullspace as returned by DomainMatrix and related classes is the
+# transpose of the nullspace as returned by Matrix. Matrix returns a list of
+# of column vectors whereas DomainMatrix returns a matrix whose rows are the
+# nullspace vectors.
+#
+
+
+NULLSPACE_EXAMPLES = [
+
+    (
+        'zz_1',
+         DM([[ 1, 2, 3]], ZZ),
+         DM([[-2, 1, 0],
+             [-3, 0, 1]], ZZ),
+    ),
+
+    (
+        'zz_2',
+         zeros((0, 0), ZZ),
+         zeros((0, 0), ZZ),
+    ),
+
+    (
+        'zz_3',
+        zeros((2, 0), ZZ),
+        zeros((0, 0), ZZ),
+    ),
+
+    (
+        'zz_4',
+        zeros((0, 2), ZZ),
+        eye(2, ZZ),
+    ),
+
+    (
+        'zz_5',
+        zeros((2, 2), ZZ),
+        eye(2, ZZ),
+    ),
+
+    (
+        'zz_6',
+        DM([[1, 2],
+            [3, 4]], ZZ),
+        zeros((0, 2), ZZ),
+    ),
+
+    (
+        'zz_7',
+        DM([[1, 1],
+            [1, 1]], ZZ),
+        DM([[-1, 1]], ZZ),
+    ),
+
+    (
+        'zz_8',
+        DM([[1],
+            [1]], ZZ),
+        zeros((0, 1), ZZ),
+    ),
+
+    (
+        'zz_9',
+        DM([[1, 1]], ZZ),
+        DM([[-1, 1]], ZZ),
+    ),
+
+    (
+        'zz_10',
+        DM([[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1]], ZZ),
+        DM([[ 0,  0, 1,  0,  0, 0, 0, 0, 0, 0],
+            [-1,  0, 0,  0,  0, 0, 1, 0, 0, 0],
+            [ 0, -1, 0,  0,  0, 0, 0, 1, 0, 0],
+            [ 0,  0, 0, -1,  0, 0, 0, 0, 1, 0],
+            [ 0,  0, 0,  0, -1, 0, 0, 0, 0, 1]], ZZ),
+    ),
+
+]
+
+
+def _to_DM(A, ans):
+    """Convert the answer to DomainMatrix."""
+    if isinstance(A, DomainMatrix):
+        return A.to_dense()
+    elif isinstance(A, DDM):
+        return DomainMatrix(list(A), A.shape, A.domain).to_dense()
+    elif isinstance(A, SDM):
+        return DomainMatrix(dict(A), A.shape, A.domain).to_dense()
+    else:
+        assert False # pragma: no cover
+
+
+def _divide_last(null):
+    """Normalize the nullspace by the rightmost non-zero entry."""
+    null = null.to_field()
+
+    if null.is_zero_matrix:
+        return null
+
+    rows = []
+    for i in range(null.shape[0]):
+        for j in reversed(range(null.shape[1])):
+            if null[i, j]:
+                rows.append(null[i, :] / null[i, j])
+                break
+        else:
+            assert False # pragma: no cover
+
+    return DomainMatrix.vstack(*rows)
+
+
+def _check_primitive(null, null_ans):
+    """Check that the primitive of the answer matches."""
+    null = _to_DM(null, null_ans)
+    cont, null_prim = null.primitive()
+    assert null_prim == null_ans
+
+
+def _check_divided(null, null_ans):
+    """Check the divided answer."""
+    null = _to_DM(null, null_ans)
+    null_ans_norm = _divide_last(null_ans)
+    assert null == null_ans_norm
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_Matrix_nullspace(name, A, A_null):
+    A = A.to_Matrix()
+
+    A_null_cols = A.nullspace()
+
+    # We have to patch up the case where the nullspace is empty
+    if A_null_cols:
+        A_null_found = Matrix.hstack(*A_null_cols)
+    else:
+        A_null_found = Matrix.zeros(A.cols, 0)
+
+    A_null_found = A_null_found.to_DM().to_field().to_dense()
+
+    # The Matrix result is the transpose of DomainMatrix result.
+    A_null_found = A_null_found.transpose()
+
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_dense_nullspace(name, A, A_null):
+    A = A.to_field().to_dense()
+    A_null_found = A.nullspace(divide_last=True)
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_sparse_nullspace(name, A, A_null):
+    A = A.to_field().to_sparse()
+    A_null_found = A.nullspace(divide_last=True)
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_ddm_nullspace(name, A, A_null):
+    A = A.to_field().to_ddm()
+    A_null_found, _ = A.nullspace()
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_sdm_nullspace(name, A, A_null):
+    A = A.to_field().to_sdm()
+    A_null_found, _ = A.nullspace()
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_dense_nullspace_fracfree(name, A, A_null):
+    A = A.to_dense()
+    A_null_found = A.nullspace()
+    _check_primitive(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_sparse_nullspace_fracfree(name, A, A_null):
+    A = A.to_sparse()
+    A_null_found = A.nullspace()
+    _check_primitive(A_null_found, A_null)

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_rref.py

@@ -0,0 +1,737 @@
+from sympy import ZZ, QQ, ZZ_I, EX, Matrix, eye, zeros, symbols
+from sympy.polys.matrices import DM, DomainMatrix
+from sympy.polys.matrices.dense import ddm_irref_den, ddm_irref
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.sdm import SDM, sdm_irref, sdm_rref_den
+
+import pytest
+
+
+#
+# The dense and sparse implementations of rref_den are ddm_irref_den and
+# sdm_irref_den. These can give results that differ by some factor and also
+# give different results if the order of the rows is changed. The tests below
+# show all results on lowest terms as should be returned by cancel_denom.
+#
+# The EX domain is also a case where the dense and sparse implementations
+# can give results in different forms: the results should be equivalent but
+# are not canonical because EX does not have a canonical form.
+#
+
+
+a, b, c, d = symbols('a, b, c, d')
+
+
+qq_large_1 = DM([
+[  (1,2),  (1,3),  (1,5),  (1,7), (1,11), (1,13), (1,17), (1,19), (1,23), (1,29), (1,31)],
+[ (1,37), (1,41), (1,43), (1,47), (1,53), (1,59), (1,61), (1,67), (1,71), (1,73), (1,79)],
+[ (1,83), (1,89), (1,97),(1,101),(1,103),(1,107),(1,109),(1,113),(1,127),(1,131),(1,137)],
+[(1,139),(1,149),(1,151),(1,157),(1,163),(1,167),(1,173),(1,179),(1,181),(1,191),(1,193)],
+[(1,197),(1,199),(1,211),(1,223),(1,227),(1,229),(1,233),(1,239),(1,241),(1,251),(1,257)],
+[(1,263),(1,269),(1,271),(1,277),(1,281),(1,283),(1,293),(1,307),(1,311),(1,313),(1,317)],
+[(1,331),(1,337),(1,347),(1,349),(1,353),(1,359),(1,367),(1,373),(1,379),(1,383),(1,389)],
+[(1,397),(1,401),(1,409),(1,419),(1,421),(1,431),(1,433),(1,439),(1,443),(1,449),(1,457)],
+[(1,461),(1,463),(1,467),(1,479),(1,487),(1,491),(1,499),(1,503),(1,509),(1,521),(1,523)],
+[(1,541),(1,547),(1,557),(1,563),(1,569),(1,571),(1,577),(1,587),(1,593),(1,599),(1,601)],
+[(1,607),(1,613),(1,617),(1,619),(1,631),(1,641),(1,643),(1,647),(1,653),(1,659),(1,661)]],
+        QQ)
+
+qq_large_2 = qq_large_1 + 10**100 * DomainMatrix.eye(11, QQ)
+
+
+RREF_EXAMPLES = [
+    (
+        'zz_1',
+         DM([[1, 2, 3]], ZZ),
+         DM([[1, 2, 3]], ZZ),
+         ZZ(1),
+    ),
+
+    (
+        'zz_2',
+         DomainMatrix([], (0, 0), ZZ),
+         DomainMatrix([], (0, 0), ZZ),
+         ZZ(1),
+    ),
+
+    (
+        'zz_3',
+        DM([[1, 2],
+            [3, 4]], ZZ),
+        DM([[1, 0],
+            [0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_4',
+        DM([[1, 0],
+            [3, 4]], ZZ),
+        DM([[1, 0],
+            [0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_5',
+        DM([[0, 2],
+            [3, 4]], ZZ),
+        DM([[1, 0],
+            [0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_6',
+        DM([[1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9]], ZZ),
+        DM([[1, 0, -1],
+            [0, 1,  2],
+            [0, 0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_7',
+        DM([[0, 0, 0],
+            [0, 0, 0],
+            [1, 0, 0]], ZZ),
+        DM([[1, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_8',
+        DM([[0, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0]], ZZ),
+        DM([[0, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_9',
+        DM([[1, 1, 0],
+            [0, 0, 2],
+            [0, 0, 0]], ZZ),
+        DM([[1, 1, 0],
+            [0, 0, 1],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_10',
+        DM([[2, 2, 0],
+            [0, 0, 2],
+            [0, 0, 0]], ZZ),
+        DM([[1, 1, 0],
+            [0, 0, 1],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_11',
+        DM([[2, 2, 0],
+            [0, 2, 2],
+            [0, 0, 2]], ZZ),
+        DM([[1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_12',
+        DM([[ 1,  2,  3],
+            [ 4,  5,  6],
+            [ 7,  8,  9],
+            [10, 11, 12]], ZZ),
+        DM([[1,  0, -1],
+            [0,  1,  2],
+            [0,  0,  0],
+            [0,  0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_13',
+        DM([[ 1,  2,  3],
+            [ 4,  5,  6],
+            [ 7,  8,  9],
+            [10, 11, 13]], ZZ),
+        DM([[ 1,  0,  0],
+            [ 0,  1,  0],
+            [ 0,  0,  1],
+            [ 0,  0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_14',
+        DM([[1, 2,  4, 3],
+            [4, 5, 10, 6],
+            [7, 8, 16, 9]], ZZ),
+        DM([[1, 0, 0, -1],
+            [0, 1, 2,  2],
+            [0, 0, 0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_15',
+        DM([[1, 2,  4, 3],
+            [4, 5, 10, 6],
+            [7, 8, 17, 9]], ZZ),
+        DM([[1, 0, 0, -1],
+            [0, 1, 0,  2],
+            [0, 0, 1,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_16',
+        DM([[1, 2, 0, 1],
+            [1, 1, 9, 0]], ZZ),
+        DM([[1, 0, 18, -1],
+            [0, 1, -9,  1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_17',
+        DM([[1, 1, 1],
+            [1, 2, 2]], ZZ),
+        DM([[1, 0, 0],
+            [0, 1, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        # Here the sparse implementation and dense implementation give very
+        # different denominators: 4061232 and -1765176.
+        'zz_18',
+        DM([[94, 24,  0, 27, 0],
+            [79,  0,  0,  0, 0],
+            [85, 16, 71, 81, 0],
+            [ 0,  0, 72, 77, 0],
+            [21,  0, 34,  0, 0]], ZZ),
+        DM([[ 1,  0,  0,  0, 0],
+            [ 0,  1,  0,  0, 0],
+            [ 0,  0,  1,  0, 0],
+            [ 0,  0,  0,  1, 0],
+            [ 0,  0,  0,  0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        # Let's have a denominator that cannot be cancelled.
+        'zz_19',
+        DM([[1, 2, 4],
+            [4, 5, 6]], ZZ),
+        DM([[3, 0, -8],
+            [0, 3, 10]], ZZ),
+        ZZ(3),
+    ),
+
+    (
+        'zz_20',
+        DM([[0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 4]], ZZ),
+        DM([[0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_21',
+        DM([[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1]], ZZ),
+        DM([[1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_22',
+        DM([[1, 1, 1, 0, 1],
+            [1, 1, 0, 1, 0],
+            [1, 0, 1, 0, 1],
+            [1, 1, 0, 1, 0],
+            [1, 0, 0, 0, 0]], ZZ),
+        DM([[1, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+            [0, 0, 1, 0, 1],
+            [0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_large_1',
+        DM([
+[ 0,  0,  0, 81,  0,  0, 75,  0,  0,  0,  0,  0,  0, 27,  0,  0,  0,  0,  0,  0],
+[ 0,  0,  0,  0,  0, 86,  0, 92, 79, 54,  0,  7,  0,  0,  0,  0, 79,  0,  0,  0],
+[89, 54, 81,  0,  0, 20,  0,  0,  0,  0,  0,  0, 51,  0, 94,  0,  0, 77,  0,  0],
+[ 0,  0,  0, 96,  0,  0,  0,  0,  0,  0,  0,  0, 48, 29,  0,  0,  5,  0, 32,  0],
+[ 0, 70,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 60,  0,  0,  0, 11],
+[ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 37,  0, 43,  0,  0],
+[ 0,  0,  0,  0,  0, 38, 91,  0,  0,  0,  0, 38,  0,  0,  0,  0,  0, 26,  0,  0],
+[69,  0,  0,  0,  0,  0, 94,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 55],
+[ 0, 13, 18, 49, 49, 88,  0,  0, 35, 54,  0,  0, 51,  0,  0,  0,  0,  0,  0, 87],
+[ 0,  0,  0,  0, 31,  0, 40,  0,  0,  0,  0,  0,  0, 50,  0,  0,  0,  0, 88,  0],
+[ 0,  0,  0,  0,  0,  0,  0,  0, 98,  0,  0,  0, 15, 53,  0, 92,  0,  0,  0,  0],
+[ 0,  0,  0, 95,  0,  0,  0, 36,  0,  0,  0,  0,  0, 72,  0,  0,  0,  0, 73, 19],
+[ 0, 65, 14, 96,  0,  0,  0,  0,  0,  0,  0,  0,  0, 90,  0,  0,  0, 34,  0,  0],
+[ 0,  0,  0, 16, 39, 44,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 51,  0,  0],
+[ 0, 17,  0,  0,  0, 99, 84, 13, 50, 84,  0,  0,  0,  0, 95,  0, 43, 33, 20,  0],
+[79,  0, 17, 52, 99, 12, 69,  0, 98,  0, 68,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+[ 0,  0,  0, 82,  0, 44,  0,  0,  0, 97,  0,  0,  0,  0,  0, 10,  0,  0, 31,  0],
+[ 0,  0, 21,  0, 67,  0,  0,  0,  0,  0,  4,  0, 50,  0,  0,  0, 33,  0,  0,  0],
+[ 0,  0,  0,  0,  9, 42,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8],
+[ 0, 77,  0,  0,  0,  0,  0,  0,  0,  0, 34, 93,  0,  0,  0,  0, 47,  0,  0,  0]],
+           ZZ),
+        DM([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_large_2',
+        DM([
+[ 0,  0,  0,  0, 50,  0,  6, 81,  0,  1, 86,  0,  0, 98, 82, 94,  4,  0,  0, 29],
+[ 0, 44, 43,  0, 62,  0,  0,  0, 60,  0,  0,  0,  0, 71,  9,  0, 57, 41,  0, 93],
+[ 0,  0, 28,  0, 74, 89, 42,  0, 28,  0,  6,  0,  0,  0, 44,  0,  0,  0, 77, 19],
+[ 0, 21, 82,  0, 30, 88,  0, 89, 68,  0,  0,  0, 79, 41,  0,  0, 99,  0,  0,  0],
+[31,  0,  0,  0, 19, 64,  0,  0, 79,  0,  5,  0, 72, 10, 60, 32, 64, 59,  0, 24],
+[ 0,  0,  0,  0,  0, 57,  0, 94,  0, 83, 20,  0,  0,  9, 31,  0, 49, 26, 58,  0],
+[ 0, 65, 56, 31, 64,  0,  0,  0,  0,  0,  0, 52, 85,  0,  0,  0,  0, 51,  0,  0],
+[ 0, 35,  0,  0,  0, 69,  0,  0, 64,  0,  0,  0,  0, 70,  0,  0, 90,  0, 75, 76],
+[69,  7,  0, 90,  0,  0, 84,  0, 47, 69, 19, 20, 42,  0,  0, 32, 71, 35,  0,  0],
+[39,  0, 90,  0,  0,  4, 85,  0,  0, 55,  0,  0,  0, 35, 67, 40,  0, 40,  0, 77],
+[98, 63,  0, 71,  0, 50,  0,  2, 61,  0, 38,  0,  0,  0,  0, 75,  0, 40, 33, 56],
+[ 0, 73,  0, 64,  0, 38,  0, 35, 61,  0,  0, 52,  0,  7,  0, 51,  0,  0,  0, 34],
+[ 0,  0, 28,  0, 34,  5, 63, 45, 14, 42, 60, 16, 76, 54, 99,  0, 28, 30,  0,  0],
+[58, 37, 14,  0,  0,  0, 94,  0,  0, 90,  0,  0,  0,  0,  0,  0,  0,  8, 90, 53],
+[86, 74, 94,  0, 49, 10, 60,  0, 40, 18,  0,  0,  0, 31, 60, 24,  0,  1,  0, 29],
+[53,  0,  0, 97,  0,  0, 58,  0,  0, 39, 44, 47,  0,  0,  0, 12, 50,  0,  0, 11],
+[ 4,  0, 92, 10, 28,  0,  0, 89,  0,  0, 18, 54, 23, 39,  0,  2,  0, 48,  0, 92],
+[ 0,  0, 90, 77, 95, 33,  0,  0, 49, 22, 39,  0,  0,  0,  0,  0,  0, 40,  0,  0],
+[96,  0,  0,  0,  0, 38, 86,  0, 22, 76,  0,  0,  0,  0, 83, 88, 95, 65, 72,  0],
+[81, 65,  0,  4, 60,  0, 19,  0,  0, 68,  0,  0, 89,  0, 67, 22,  0,  0, 55, 33]],
+           ZZ),
+        DM([
+[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]],
+           ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_large_3',
+        DM([
+[62,35,89,58,22,47,30,28,52,72,17,56,80,26,64,21,10,35,24,42,96,32,23,50,92,37,76,94,63,66],
+[20,47,96,34,10,98,19,6,29,2,19,92,61,94,38,41,32,9,5,94,31,58,27,41,72,85,61,62,40,46],
+[69,26,35,68,25,52,94,13,38,65,81,10,29,15,5,4,13,99,85,0,80,51,60,60,26,77,85,2,87,25],
+[99,58,69,15,52,12,18,7,27,56,12,54,21,92,38,95,33,83,28,1,44,8,29,84,92,12,2,25,46,46],
+[93,13,55,48,35,87,24,40,23,35,25,32,0,19,0,85,4,79,26,11,46,75,7,96,76,11,7,57,99,75],
+[128,85,26,51,161,173,77,78,85,103,123,58,91,147,38,91,161,36,123,81,102,25,75,59,17,150,112,65,77,143],
+[15,59,61,82,12,83,34,8,94,71,66,7,91,21,48,69,26,12,64,38,97,87,38,15,51,33,93,43,66,89],
+[74,74,53,39,69,90,41,80,32,66,40,83,87,87,61,38,12,80,24,49,37,90,19,33,56,0,46,57,56,60],
+[82,11,0,25,56,58,39,49,92,93,80,38,19,62,33,85,19,61,14,30,45,91,97,34,97,53,92,28,33,43],
+[83,79,41,16,95,35,53,45,26,4,71,76,61,69,69,72,87,92,59,72,54,11,22,83,8,57,77,55,19,22],
+[49,34,13,31,72,77,52,70,46,41,37,6,42,66,35,6,75,33,62,57,30,14,26,31,9,95,89,13,12,90],
+[29,3,49,30,51,32,77,41,38,50,16,1,87,81,93,88,58,91,83,0,38,67,29,64,60,84,5,60,23,28],
+[79,51,13,20,89,96,25,8,39,62,86,52,49,81,3,85,86,3,61,24,72,11,49,28,8,55,23,52,65,53],
+[96,86,73,20,41,20,37,18,10,61,85,24,40,83,69,41,4,92,23,99,64,33,18,36,32,56,60,98,39,24],
+[32,62,47,80,51,66,17,1,9,30,65,75,75,88,99,92,64,53,53,86,38,51,41,14,35,18,39,25,26,32],
+[39,21,8,16,33,6,35,85,75,62,43,34,18,68,71,28,32,18,12,0,81,53,1,99,3,5,45,99,35,33],
+[19,95,89,45,75,94,92,5,84,93,34,17,50,56,79,98,68,82,65,81,51,90,5,95,33,71,46,61,14,7],
+[53,92,8,49,67,84,21,79,49,95,66,48,36,14,62,97,26,45,58,31,83,48,11,89,67,72,91,34,56,89],
+[56,76,99,92,40,8,0,16,15,48,35,72,91,46,81,14,86,60,51,7,33,12,53,78,48,21,3,89,15,79],
+[81,43,33,49,6,49,36,32,57,74,87,91,17,37,31,17,67,1,40,38,69,8,3,48,59,37,64,97,11,3],
+[98,48,77,16,2,48,57,38,63,59,79,35,16,71,60,86,71,41,14,76,80,97,77,69,4,58,22,55,26,73],
+[80,47,78,44,31,48,47,29,29,62,19,21,17,24,19,3,53,93,97,57,13,54,12,10,77,66,60,75,32,21],
+[86,63,2,13,71,38,86,23,18,15,91,65,77,65,9,92,50,0,17,42,99,80,99,27,10,99,92,9,87,84],
+[66,27,72,13,13,15,72,75,39,3,14,71,15,68,10,19,49,54,11,29,47,20,63,13,97,47,24,62,16,96],
+[42,63,83,60,49,68,9,53,75,87,40,25,12,63,0,12,0,95,46,46,55,25,89,1,51,1,1,96,80,52],
+[35,9,97,13,86,39,66,48,41,57,23,38,11,9,35,72,88,13,41,60,10,64,71,23,1,5,23,57,6,19],
+[70,61,5,50,72,60,77,13,41,94,1,45,52,22,99,47,27,18,99,42,16,48,26,9,88,77,10,94,11,92],
+[55,68,58,2,72,56,81,52,79,37,1,40,21,46,27,60,37,13,97,42,85,98,69,60,76,44,42,46,29,73],
+[73,0,43,17,89,97,45,2,68,14,55,60,95,2,74,85,88,68,93,76,38,76,2,51,45,76,50,79,56,18],
+[72,58,41,39,24,80,23,79,44,7,98,75,30,6,85,60,20,58,77,71,90,51,38,80,30,15,33,10,82,8]],
+            ZZ),
+        Matrix([
+    [eye(29) * 2028539767964472550625641331179545072876560857886207583101,
+     Matrix([ 4260575808093245475167216057435155595594339172099000182569,
+              169148395880755256182802335904188369274227936894862744452,
+              4915975976683942569102447281579134986891620721539038348914,
+              6113916866367364958834844982578214901958429746875633283248,
+              5585689617819894460378537031623265659753379011388162534838,
+              359776822829880747716695359574308645968094838905181892423,
+              -2800926112141776386671436511182421432449325232461665113305,
+              941642292388230001722444876624818265766384442910688463158,
+              3648811843256146649321864698600908938933015862008642023935,
+              -4104526163246702252932955226754097174212129127510547462419,
+              -704814955438106792441896903238080197619233342348191408078,
+              1640882266829725529929398131287244562048075707575030019335,
+              -4068330845192910563212155694231438198040299927120544468520,
+              136589038308366497790495711534532612862715724187671166593,
+              2544937011460702462290799932536905731142196510605191645593,
+              755591839174293940486133926192300657264122907519174116472,
+              -3683838489869297144348089243628436188645897133242795965021,
+              -522207137101161299969706310062775465103537953077871128403,
+              -2260451796032703984456606059649402832441331339246756656334,
+              -6476809325293587953616004856993300606040336446656916663680,
+              3521944238996782387785653800944972787867472610035040989081,
+              2270762115788407950241944504104975551914297395787473242379,
+              -3259947194628712441902262570532921252128444706733549251156,
+              -5624569821491886970999097239695637132075823246850431083557,
+              -3262698255682055804320585332902837076064075936601504555698,
+              5786719943788937667411185880136324396357603606944869545501,
+              -955257841973865996077323863289453200904051299086000660036,
+              -1294235552446355326174641248209752679127075717918392702116,
+              -3718353510747301598130831152458342785269166356215331448279,
+             ]),],
+        [zeros(1, 29), zeros(1, 1)],
+        ]).to_DM().to_dense(),
+        ZZ(2028539767964472550625641331179545072876560857886207583101),
+    ),
+
+
+    (
+        'qq_1',
+        DM([[(1,2), 0], [0, 2]], QQ),
+        DM([[1, 0], [0, 1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # Standard square case
+        'qq_2',
+        DM([[0, 1],
+            [1, 1]], QQ),
+        DM([[1, 0],
+            [0, 1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # m < n  case
+        'qq_3',
+        DM([[1, 2, 1],
+            [3, 4, 1]], QQ),
+        DM([[1, 0, -1],
+            [0, 1,  1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # same m < n  but reversed
+        'qq_4',
+        DM([[3, 4, 1],
+            [1, 2, 1]], QQ),
+        DM([[1, 0, -1],
+            [0, 1,  1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # m > n case
+        'qq_5',
+        DM([[1, 0],
+            [1, 3],
+            [0, 1]], QQ),
+        DM([[1, 0],
+            [0, 1],
+            [0, 0]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # Example with missing pivot
+        'qq_6',
+        DM([[1, 0, 1],
+            [3, 0, 1]], QQ),
+        DM([[1, 0, 0],
+            [0, 0, 1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # This is intended to trigger the threshold where we give up on
+        # clearing denominators.
+        'qq_large_1',
+        qq_large_1,
+        DomainMatrix.eye(11, QQ).to_dense(),
+        QQ(1),
+    ),
+
+    (
+        # This is intended to trigger the threshold where we use rref_den over
+        # QQ.
+        'qq_large_2',
+        qq_large_2,
+        DomainMatrix.eye(11, QQ).to_dense(),
+        QQ(1),
+    ),
+
+    (
+        # Example with missing pivot and no replacement
+
+        # This example is just enough to show a different result from the dense
+        # and sparse versions of the algorithm:
+        #
+        #   >>> A = Matrix([[0, 1], [0, 2], [1, 0]])
+        #   >>> A.to_DM().to_sparse().rref_den()[0].to_Matrix()
+        #   Matrix([
+        #   [1, 0],
+        #   [0, 1],
+        #   [0, 0]])
+        #   >>> A.to_DM().to_dense().rref_den()[0].to_Matrix()
+        #   Matrix([
+        #   [2, 0],
+        #   [0, 2],
+        #   [0, 0]])
+        #
+        'qq_7',
+        DM([[0, 1],
+            [0, 2],
+            [1, 0]], QQ),
+        DM([[1, 0],
+            [0, 1],
+            [0, 0]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # Gaussian integers
+        'zz_i_1',
+        DM([[(0,1), 1, 1],
+            [    1, 1, 1]], ZZ_I),
+        DM([[1, 0, 0],
+            [0, 1, 1]], ZZ_I),
+        ZZ_I(1),
+    ),
+
+    (
+        # EX: test_issue_23718
+        'EX_1',
+        DM([
+        [a, b, 1],
+        [c, d, 1]], EX),
+        DM([[a*d - b*c,         0, -b + d],
+            [        0, a*d - b*c,  a - c]], EX),
+        EX(a*d - b*c),
+    ),
+
+]
+
+
+def _to_DM(A, ans):
+    """Convert the answer to DomainMatrix."""
+    if isinstance(A, DomainMatrix):
+        return A.to_dense()
+    elif isinstance(A, Matrix):
+        return A.to_DM(ans.domain).to_dense()
+
+    if not (hasattr(A, 'shape') and hasattr(A, 'domain')):
+        shape, domain = ans.shape, ans.domain
+    else:
+        shape, domain = A.shape, A.domain
+
+    if isinstance(A, (DDM, list)):
+        return DomainMatrix(list(A), shape, domain).to_dense()
+    elif isinstance(A, (SDM, dict)):
+        return DomainMatrix(dict(A), shape, domain).to_dense()
+    else:
+        assert False # pragma: no cover
+
+
+def _pivots(A_rref):
+    """Return the pivots from the rref of A."""
+    return tuple(sorted(map(min, A_rref.to_sdm().values())))
+
+
+def _check_cancel(result, rref_ans, den_ans):
+    """Check the cancelled result."""
+    rref, den, pivots = result
+    if isinstance(rref, (DDM, SDM, list, dict)):
+        assert type(pivots) is list
+        pivots = tuple(pivots)
+    rref = _to_DM(rref, rref_ans)
+    rref2, den2 = rref.cancel_denom(den)
+    assert rref2 == rref_ans
+    assert den2 == den_ans
+    assert pivots == _pivots(rref)
+
+
+def _check_divide(result, rref_ans, den_ans):
+    """Check the divided result."""
+    rref, pivots = result
+    if isinstance(rref, (DDM, SDM, list, dict)):
+        assert type(pivots) is list
+        pivots = tuple(pivots)
+    rref_ans = rref_ans.to_field() / den_ans
+    rref = _to_DM(rref, rref_ans)
+    assert rref == rref_ans
+    assert _pivots(rref) == pivots
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_Matrix_rref(name, A, A_rref, den):
+    K = A.domain
+    A = A.to_Matrix()
+    A_rref_found, pivots = A.rref()
+    if K.is_EX:
+        A_rref_found = A_rref_found.expand()
+    _check_divide((A_rref_found, pivots), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_dense_rref(name, A, A_rref, den):
+    A = A.to_field()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_dense_rref_den(name, A, A_rref, den):
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref(name, A, A_rref, den):
+    A = A.to_field().to_sparse()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den(name, A, A_rref, den):
+    A = A.to_sparse()
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den_keep_domain(name, A, A_rref, den):
+    A = A.to_sparse()
+    A_rref_f, den_f, pivots_f = A.rref_den(keep_domain=False)
+    A_rref_f = A_rref_f.to_field() / den_f
+    _check_divide((A_rref_f, pivots_f), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den_keep_domain_CD(name, A, A_rref, den):
+    A = A.to_sparse()
+    A_rref_f, den_f, pivots_f = A.rref_den(keep_domain=False, method='CD')
+    A_rref_f = A_rref_f.to_field() / den_f
+    _check_divide((A_rref_f, pivots_f), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den_keep_domain_GJ(name, A, A_rref, den):
+    A = A.to_sparse()
+    A_rref_f, den_f, pivots_f = A.rref_den(keep_domain=False, method='GJ')
+    A_rref_f = A_rref_f.to_field() / den_f
+    _check_divide((A_rref_f, pivots_f), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_rref_den(name, A, A_rref, den):
+    A = A.to_ddm()
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sdm_rref_den(name, A, A_rref, den):
+    A = A.to_sdm()
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_rref(name, A, A_rref, den):
+    A = A.to_field().to_ddm()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sdm_rref(name, A, A_rref, den):
+    A = A.to_field().to_sdm()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_irref(name, A, A_rref, den):
+    A = A.to_field().to_ddm().copy()
+    pivots_found = ddm_irref(A)
+    _check_divide((A, pivots_found), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_irref_den(name, A, A_rref, den):
+    A = A.to_ddm().copy()
+    (den_found, pivots_found) = ddm_irref_den(A, A.domain)
+    result = (A, den_found, pivots_found)
+    _check_cancel(result, A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sparse_sdm_rref(name, A, A_rref, den):
+    A = A.to_field().to_sdm()
+    _check_divide(sdm_irref(A)[:2], A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sparse_sdm_rref_den(name, A, A_rref, den):
+    A = A.to_sdm().copy()
+    K = A.domain
+    _check_cancel(sdm_rref_den(A, K), A_rref, den)

venv/lib/python3.12/site-packages/sympy/polys/matrices/tests/test_sdm.py

@@ -0,0 +1,428 @@
+"""
+Tests for the basic functionality of the SDM class.
+"""
+
+from itertools import product
+
+from sympy.core.singleton import S
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.testing.pytest import raises
+
+from sympy.polys.domains import QQ, ZZ, EXRAW
+from sympy.polys.matrices.sdm import SDM
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.exceptions import (DMBadInputError, DMDomainError,
+                                             DMShapeError)
+
+
+def test_SDM():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {0:{0:ZZ(1)}}
+
+    raises(DMBadInputError, lambda: SDM({5:{1:ZZ(0)}}, (2, 2), ZZ))
+    raises(DMBadInputError, lambda: SDM({0:{5:ZZ(0)}}, (2, 2), ZZ))
+
+
+def test_DDM_str():
+    sdm = SDM({0:{0:ZZ(1)}, 1:{1:ZZ(1)}}, (2, 2), ZZ)
+    assert str(sdm) == '{0: {0: 1}, 1: {1: 1}}'
+    if GROUND_TYPES == 'gmpy': # pragma: no cover
+        assert repr(sdm) == 'SDM({0: {0: mpz(1)}, 1: {1: mpz(1)}}, (2, 2), ZZ)'
+    else:        # pragma: no cover
+        assert repr(sdm) == 'SDM({0: {0: 1}, 1: {1: 1}}, (2, 2), ZZ)'
+
+
+def test_SDM_new():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    B = A.new({}, (2, 2), ZZ)
+    assert B == SDM({}, (2, 2), ZZ)
+
+
+def test_SDM_copy():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    B = A.copy()
+    assert A == B
+    A[0][0] = ZZ(2)
+    assert A != B
+
+
+def test_SDM_from_list():
+    A = SDM.from_list([[ZZ(0), ZZ(1)], [ZZ(1), ZZ(0)]], (2, 2), ZZ)
+    assert A == SDM({0:{1:ZZ(1)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+
+    raises(DMBadInputError, lambda: SDM.from_list([[ZZ(0)], [ZZ(0), ZZ(1)]], (2, 2), ZZ))
+    raises(DMBadInputError, lambda: SDM.from_list([[ZZ(0), ZZ(1)]], (2, 2), ZZ))
+
+
+def test_SDM_to_list():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_list() == [[ZZ(0), ZZ(1)], [ZZ(0), ZZ(0)]]
+
+    A = SDM({}, (0, 2), ZZ)
+    assert A.to_list() == []
+
+    A = SDM({}, (2, 0), ZZ)
+    assert A.to_list() == [[], []]
+
+
+def test_SDM_to_list_flat():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_list_flat() == [ZZ(0), ZZ(1), ZZ(0), ZZ(0)]
+
+
+def test_SDM_to_dok():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_dok() == {(0, 1): ZZ(1)}
+
+
+def test_SDM_from_ddm():
+    A = DDM([[ZZ(1), ZZ(0)], [ZZ(1), ZZ(0)]], (2, 2), ZZ)
+    B = SDM.from_ddm(A)
+    assert B.domain == ZZ
+    assert B.shape == (2, 2)
+    assert dict(B) == {0:{0:ZZ(1)}, 1:{0:ZZ(1)}}
+
+
+def test_SDM_to_ddm():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    B = DDM([[ZZ(0), ZZ(1)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
+    assert A.to_ddm() == B
+
+
+def test_SDM_to_sdm():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_sdm() == A
+
+
+def test_SDM_getitem():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    assert A.getitem(0, 0) == ZZ.zero
+    assert A.getitem(0, 1) == ZZ.one
+    assert A.getitem(1, 0) == ZZ.zero
+    assert A.getitem(-2, -2) == ZZ.zero
+    assert A.getitem(-2, -1) == ZZ.one
+    assert A.getitem(-1, -2) == ZZ.zero
+    raises(IndexError, lambda: A.getitem(2, 0))
+    raises(IndexError, lambda: A.getitem(0, 2))
+
+
+def test_SDM_setitem():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(0, 0, ZZ(1))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(1, 0, ZZ(1))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(1, 0, ZZ(0))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    # Repeat the above test so that this time the row is empty
+    A.setitem(1, 0, ZZ(0))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(0, 0, ZZ(0))
+    assert A == SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    # This time the row is there but column is empty
+    A.setitem(0, 0, ZZ(0))
+    assert A == SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    raises(IndexError, lambda: A.setitem(2, 0, ZZ(1)))
+    raises(IndexError, lambda: A.setitem(0, 2, ZZ(1)))
+
+
+def test_SDM_extract_slice():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract_slice(slice(1, 2), slice(1, 2))
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+
+
+def test_SDM_extract():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract([1], [1])
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+    B = A.extract([1, 0], [1, 0])
+    assert B == SDM({0:{0:ZZ(4), 1:ZZ(3)}, 1:{0:ZZ(2), 1:ZZ(1)}}, (2, 2), ZZ)
+    B = A.extract([1, 1], [1, 1])
+    assert B == SDM({0:{0:ZZ(4), 1:ZZ(4)}, 1:{0:ZZ(4), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract([-1], [-1])
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+
+    A = SDM({}, (2, 2), ZZ)
+    B = A.extract([0, 1, 0], [0, 0])
+    assert B == SDM({}, (3, 2), ZZ)
+
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.extract([], []) == SDM.zeros((0, 0), ZZ)
+    assert A.extract([1], []) == SDM.zeros((1, 0), ZZ)
+    assert A.extract([], [1]) == SDM.zeros((0, 1), ZZ)
+
+    raises(IndexError, lambda: A.extract([2], [0]))
+    raises(IndexError, lambda: A.extract([0], [2]))
+    raises(IndexError, lambda: A.extract([-3], [0]))
+    raises(IndexError, lambda: A.extract([0], [-3]))
+
+
+def test_SDM_zeros():
+    A = SDM.zeros((2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {}
+
+def test_SDM_ones():
+    A = SDM.ones((1, 2), QQ)
+    assert A.domain == QQ
+    assert A.shape == (1, 2)
+    assert dict(A) == {0:{0:QQ(1), 1:QQ(1)}}
+
+def test_SDM_eye():
+    A = SDM.eye((2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {0:{0:ZZ(1)}, 1:{1:ZZ(1)}}
+
+
+def test_SDM_diag():
+    A = SDM.diag([ZZ(1), ZZ(2)], ZZ, (2, 3))
+    assert A == SDM({0:{0:ZZ(1)}, 1:{1:ZZ(2)}}, (2, 3), ZZ)
+
+
+def test_SDM_transpose():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1), 1:ZZ(3)}, 1:{0:ZZ(2), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.transpose() == B
+
+    A = SDM({0:{1:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({1:{0:ZZ(2)}}, (2, 2), ZZ)
+    assert A.transpose() == B
+
+    A = SDM({0:{1:ZZ(2)}}, (1, 2), ZZ)
+    B = SDM({1:{0:ZZ(2)}}, (2, 1), ZZ)
+    assert A.transpose() == B
+
+
+def test_SDM_mul():
+    A = SDM({0:{0:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A*ZZ(2) == B
+    assert ZZ(2)*A == B
+
+    raises(TypeError, lambda: A*QQ(1, 2))
+    raises(TypeError, lambda: QQ(1, 2)*A)
+
+
+def test_SDM_mul_elementwise():
+    A = SDM({0:{0:ZZ(2), 1:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}, 1:{0:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(8)}}, (2, 2), ZZ)
+    assert A.mul_elementwise(B) == C
+    assert B.mul_elementwise(A) == C
+
+    Aq = A.convert_to(QQ)
+    A1 = SDM({0:{0:ZZ(1)}}, (1, 1), ZZ)
+
+    raises(DMDomainError, lambda: Aq.mul_elementwise(B))
+    raises(DMShapeError, lambda: A1.mul_elementwise(B))
+
+
+def test_SDM_matmul():
+    A = SDM({0:{0:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A.matmul(A) == A*A == B
+
+    C = SDM({0:{0:ZZ(2)}}, (2, 2), QQ)
+    raises(DMDomainError, lambda: A.matmul(C))
+
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(7), 1:ZZ(10)}, 1:{0:ZZ(15), 1:ZZ(22)}}, (2, 2), ZZ)
+    assert A.matmul(A) == A*A == B
+
+    A22 = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    A32 = SDM({0:{0:ZZ(2)}}, (3, 2), ZZ)
+    A23 = SDM({0:{0:ZZ(4)}}, (2, 3), ZZ)
+    A33 = SDM({0:{0:ZZ(8)}}, (3, 3), ZZ)
+    A22 = SDM({0:{0:ZZ(8)}}, (2, 2), ZZ)
+    assert A32.matmul(A23) == A33
+    assert A23.matmul(A32) == A22
+    # XXX: @ not supported by SDM...
+    #assert A32.matmul(A23) == A32 @ A23 == A33
+    #assert A23.matmul(A32) == A23 @ A32 == A22
+    #raises(DMShapeError, lambda: A23 @ A22)
+    raises(DMShapeError, lambda: A23.matmul(A22))
+
+    A = SDM({0: {0: ZZ(-1), 1: ZZ(1)}}, (1, 2), ZZ)
+    B = SDM({0: {0: ZZ(-1)}, 1: {0: ZZ(-1)}}, (2, 1), ZZ)
+    assert A.matmul(B) == A*B == SDM({}, (1, 1), ZZ)
+
+
+def test_matmul_exraw():
+
+    def dm(d):
+        result = {}
+        for i, row in d.items():
+            row = {j:val for j, val in row.items() if val}
+            if row:
+                result[i] = row
+        return SDM(result, (2, 2), EXRAW)
+
+    values = [S.NegativeInfinity, S.NegativeOne, S.Zero, S.One, S.Infinity]
+    for a, b, c, d in product(*[values]*4):
+        Ad = dm({0: {0:a, 1:b}, 1: {0:c, 1:d}})
+        Ad2 = dm({0: {0:a*a + b*c, 1:a*b + b*d}, 1:{0:c*a + d*c, 1: c*b + d*d}})
+        assert Ad * Ad == Ad2
+
+
+def test_SDM_add():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{1:ZZ(6)}}, (2, 2), ZZ)
+    assert A.add(B) == B.add(A) == A + B == B + A == C
+
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    assert A.add(B) == B.add(A) == A + B == B + A == C
+
+    raises(TypeError, lambda: A + [])
+
+
+def test_SDM_sub():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(-1), 1:ZZ(1)}, 1:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A.sub(B) == A - B == C
+
+    raises(TypeError, lambda: A - [])
+
+
+def test_SDM_neg():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{1:ZZ(-1)}, 1:{0:ZZ(-2), 1:ZZ(-3)}}, (2, 2), ZZ)
+    assert A.neg() == -A == B
+
+
+def test_SDM_convert_to():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{1:QQ(1)}, 1:{0:QQ(2), 1:QQ(3)}}, (2, 2), QQ)
+    C = A.convert_to(QQ)
+    assert C == B
+    assert C.domain == QQ
+
+    D = A.convert_to(ZZ)
+    assert D == A
+    assert D.domain == ZZ
+
+
+def test_SDM_hstack():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({1:{1:ZZ(1)}}, (2, 2), ZZ)
+    AA = SDM({0:{1:ZZ(1), 3:ZZ(1)}}, (2, 4), ZZ)
+    AB = SDM({0:{1:ZZ(1)}, 1:{3:ZZ(1)}}, (2, 4), ZZ)
+    assert SDM.hstack(A) == A
+    assert SDM.hstack(A, A) == AA
+    assert SDM.hstack(A, B) == AB
+
+
+def test_SDM_vstack():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({1:{1:ZZ(1)}}, (2, 2), ZZ)
+    AA = SDM({0:{1:ZZ(1)}, 2:{1:ZZ(1)}}, (4, 2), ZZ)
+    AB = SDM({0:{1:ZZ(1)}, 3:{1:ZZ(1)}}, (4, 2), ZZ)
+    assert SDM.vstack(A) == A
+    assert SDM.vstack(A, A) == AA
+    assert SDM.vstack(A, B) == AB
+
+
+def test_SDM_applyfunc():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({0:{1:ZZ(2)}}, (2, 2), ZZ)
+    assert A.applyfunc(lambda x: 2*x, ZZ) == B
+
+
+def test_SDM_inv():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    B = SDM({0:{0:QQ(-2), 1:QQ(1)}, 1:{0:QQ(3, 2), 1:QQ(-1, 2)}}, (2, 2), QQ)
+    assert A.inv() == B
+
+
+def test_SDM_det():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.det() == QQ(-2)
+
+
+def test_SDM_lu():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    L = SDM({0:{0:QQ(1)}, 1:{0:QQ(3), 1:QQ(1)}}, (2, 2), QQ)
+    #U = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(-2)}}, (2, 2), QQ)
+    #swaps = []
+    # This doesn't quite work. U has some nonzero elements in the lower part.
+    #assert A.lu() == (L, U, swaps)
+    assert A.lu()[0] == L
+
+
+def test_SDM_lu_solve():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ)
+    x = SDM({1:{0:QQ(1, 2)}}, (2, 1), QQ)
+    assert A.matmul(x) == b
+    assert A.lu_solve(b) == x
+
+
+def test_SDM_charpoly():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.charpoly() == [ZZ(1), ZZ(-5), ZZ(-2)]
+
+
+def test_SDM_nullspace():
+    # More tests are in test_nullspace.py
+    A = SDM({0:{0:QQ(1), 1:QQ(1)}}, (2, 2), QQ)
+    assert A.nullspace()[0] == SDM({0:{0:QQ(-1), 1:QQ(1)}}, (1, 2), QQ)
+
+
+def test_SDM_rref():
+    # More tests are in test_rref.py
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2)},
+             1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    A_rref = SDM({0:{0:QQ(1)}, 1:{1:QQ(1)}}, (2, 2), QQ)
+    assert A.rref() == (A_rref, [0, 1])
+
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(2)},
+             1: {0: QQ(3),           2: QQ(4)}}, (2, 3), ZZ)
+    A_rref = SDM({0: {0: QQ(1,1), 2: QQ(4,3)},
+                  1: {1: QQ(1,1), 2: QQ(1,3)}}, (2, 3), QQ)
+    assert A.rref() == (A_rref, [0, 1])
+
+
+def test_SDM_particular():
+    A = SDM({0:{0:QQ(1)}}, (2, 2), QQ)
+    Apart = SDM.zeros((1, 2), QQ)
+    assert A.particular() == Apart
+
+
+def test_SDM_is_zero_matrix():
+    A = SDM({0: {0: QQ(1)}}, (2, 2), QQ)
+    Azero = SDM.zeros((1, 2), QQ)
+    assert A.is_zero_matrix() is False
+    assert Azero.is_zero_matrix() is True
+
+
+def test_SDM_is_upper():
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                                 2: {2: QQ(8), 3: QQ(9)}}, (3, 4), QQ)
+    B = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                       2: {1: QQ(7), 2: QQ(8), 3: QQ(9)}}, (3, 4), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+
+def test_SDM_is_lower():
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                                 2: {2: QQ(8), 3: QQ(9)}}, (3, 4), QQ
+            ).transpose()
+    B = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                       2: {1: QQ(7), 2: QQ(8), 3: QQ(9)}}, (3, 4), QQ
+            ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False