Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/__init__.py

@@ -0,0 +1,5 @@
+"""Module for algebraic geometry and commutative algebra."""
+
+from .homomorphisms import homomorphism
+
+__all__ = ['homomorphism']

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/extensions.py

@@ -0,0 +1,346 @@
+"""Finite extensions of ring domains."""
+
+from sympy.polys.domains.domain import Domain
+from sympy.polys.domains.domainelement import DomainElement
+from sympy.polys.polyerrors import (CoercionFailed, NotInvertible,
+        GeneratorsError)
+from sympy.polys.polytools import Poly
+from sympy.printing.defaults import DefaultPrinting
+
+
+class ExtensionElement(DomainElement, DefaultPrinting):
+    """
+    Element of a finite extension.
+
+    A class of univariate polynomials modulo the ``modulus``
+    of the extension ``ext``. It is represented by the
+    unique polynomial ``rep`` of lowest degree. Both
+    ``rep`` and the representation ``mod`` of ``modulus``
+    are of class DMP.
+
+    """
+    __slots__ = ('rep', 'ext')
+
+    def __init__(self, rep, ext):
+        self.rep = rep
+        self.ext = ext
+
+    def parent(f):
+        return f.ext
+
+    def __bool__(f):
+        return bool(f.rep)
+
+    def __pos__(f):
+        return f
+
+    def __neg__(f):
+        return ExtElem(-f.rep, f.ext)
+
+    def _get_rep(f, g):
+        if isinstance(g, ExtElem):
+            if g.ext == f.ext:
+                return g.rep
+            else:
+                return None
+        else:
+            try:
+                g = f.ext.convert(g)
+                return g.rep
+            except CoercionFailed:
+                return None
+
+    def __add__(f, g):
+        rep = f._get_rep(g)
+        if rep is not None:
+            return ExtElem(f.rep + rep, f.ext)
+        else:
+            return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(f, g):
+        rep = f._get_rep(g)
+        if rep is not None:
+            return ExtElem(f.rep - rep, f.ext)
+        else:
+            return NotImplemented
+
+    def __rsub__(f, g):
+        rep = f._get_rep(g)
+        if rep is not None:
+            return ExtElem(rep - f.rep, f.ext)
+        else:
+            return NotImplemented
+
+    def __mul__(f, g):
+        rep = f._get_rep(g)
+        if rep is not None:
+            return ExtElem((f.rep * rep) % f.ext.mod, f.ext)
+        else:
+            return NotImplemented
+
+    __rmul__ = __mul__
+
+    def _divcheck(f):
+        """Raise if division is not implemented for this divisor"""
+        if not f:
+            raise NotInvertible('Zero divisor')
+        elif f.ext.is_Field:
+            return True
+        elif f.rep.is_ground and f.ext.domain.is_unit(f.rep.rep[0]):
+            return True
+        else:
+            # Some cases like (2*x + 2)/2 over ZZ will fail here. It is
+            # unclear how to implement division in general if the ground
+            # domain is not a field so for now it was decided to restrict the
+            # implementation to division by invertible constants.
+            msg = (f"Can not invert {f} in {f.ext}. "
+                    "Only division by invertible constants is implemented.")
+            raise NotImplementedError(msg)
+
+    def inverse(f):
+        """Multiplicative inverse.
+
+        Raises
+        ======
+
+        NotInvertible
+            If the element is a zero divisor.
+
+        """
+        f._divcheck()
+
+        if f.ext.is_Field:
+            invrep = f.rep.invert(f.ext.mod)
+        else:
+            R = f.ext.ring
+            invrep = R.exquo(R.one, f.rep)
+
+        return ExtElem(invrep, f.ext)
+
+    def __truediv__(f, g):
+        rep = f._get_rep(g)
+        if rep is None:
+            return NotImplemented
+        g = ExtElem(rep, f.ext)
+
+        try:
+            ginv = g.inverse()
+        except NotInvertible:
+            raise ZeroDivisionError(f"{f} / {g}")
+
+        return f * ginv
+
+    __floordiv__ = __truediv__
+
+    def __rtruediv__(f, g):
+        try:
+            g = f.ext.convert(g)
+        except CoercionFailed:
+            return NotImplemented
+        return g / f
+
+    __rfloordiv__ = __rtruediv__
+
+    def __mod__(f, g):
+        rep = f._get_rep(g)
+        if rep is None:
+            return NotImplemented
+        g = ExtElem(rep, f.ext)
+
+        try:
+            g._divcheck()
+        except NotInvertible:
+            raise ZeroDivisionError(f"{f} % {g}")
+
+        # Division where defined is always exact so there is no remainder
+        return f.ext.zero
+
+    def __rmod__(f, g):
+        try:
+            g = f.ext.convert(g)
+        except CoercionFailed:
+            return NotImplemented
+        return g % f
+
+    def __pow__(f, n):
+        if not isinstance(n, int):
+            raise TypeError("exponent of type 'int' expected")
+        if n < 0:
+            try:
+                f, n = f.inverse(), -n
+            except NotImplementedError:
+                raise ValueError("negative powers are not defined")
+
+        b = f.rep
+        m = f.ext.mod
+        r = f.ext.one.rep
+        while n > 0:
+            if n % 2:
+                r = (r*b) % m
+            b = (b*b) % m
+            n //= 2
+
+        return ExtElem(r, f.ext)
+
+    def __eq__(f, g):
+        if isinstance(g, ExtElem):
+            return f.rep == g.rep and f.ext == g.ext
+        else:
+            return NotImplemented
+
+    def __ne__(f, g):
+        return not f == g
+
+    def __hash__(f):
+        return hash((f.rep, f.ext))
+
+    def __str__(f):
+        from sympy.printing.str import sstr
+        return sstr(f.rep)
+
+    __repr__ = __str__
+
+    @property
+    def is_ground(f):
+        return f.rep.is_ground
+
+    def to_ground(f):
+        [c] = f.rep.to_list()
+        return c
+
+ExtElem = ExtensionElement
+
+
+class MonogenicFiniteExtension(Domain):
+    r"""
+    Finite extension generated by an integral element.
+
+    The generator is defined by a monic univariate
+    polynomial derived from the argument ``mod``.
+
+    A shorter alias is ``FiniteExtension``.
+
+    Examples
+    ========
+
+    Quadratic integer ring $\mathbb{Z}[\sqrt2]$:
+
+    >>> from sympy import Symbol, Poly
+    >>> from sympy.polys.agca.extensions import FiniteExtension
+    >>> x = Symbol('x')
+    >>> R = FiniteExtension(Poly(x**2 - 2)); R
+    ZZ[x]/(x**2 - 2)
+    >>> R.rank
+    2
+    >>> R(1 + x)*(3 - 2*x)
+    x - 1
+
+    Finite field $GF(5^3)$ defined by the primitive
+    polynomial $x^3 + x^2 + 2$ (over $\mathbb{Z}_5$).
+
+    >>> F = FiniteExtension(Poly(x**3 + x**2 + 2, modulus=5)); F
+    GF(5)[x]/(x**3 + x**2 + 2)
+    >>> F.basis
+    (1, x, x**2)
+    >>> F(x + 3)/(x**2 + 2)
+    -2*x**2 + x + 2
+
+    Function field of an elliptic curve:
+
+    >>> t = Symbol('t')
+    >>> FiniteExtension(Poly(t**2 - x**3 - x + 1, t, field=True))
+    ZZ(x)[t]/(t**2 - x**3 - x + 1)
+
+    """
+    is_FiniteExtension = True
+
+    dtype = ExtensionElement
+
+    def __init__(self, mod):
+        if not (isinstance(mod, Poly) and mod.is_univariate):
+            raise TypeError("modulus must be a univariate Poly")
+
+        # Using auto=True (default) potentially changes the ground domain to a
+        # field whereas auto=False raises if division is not exact.  We'll let
+        # the caller decide whether or not they want to put the ground domain
+        # over a field. In most uses mod is already monic.
+        mod = mod.monic(auto=False)
+
+        self.rank = mod.degree()
+        self.modulus = mod
+        self.mod = mod.rep  # DMP representation
+
+        self.domain = dom = mod.domain
+        self.ring = mod.rep.ring or dom.old_poly_ring(*mod.gens)
+
+        self.zero = self.convert(self.ring.zero)
+        self.one = self.convert(self.ring.one)
+
+        gen = self.ring.gens[0]
+        self.symbol = self.ring.symbols[0]
+        self.generator = self.convert(gen)
+        self.basis = tuple(self.convert(gen**i) for i in range(self.rank))
+
+        # XXX: It might be necessary to check mod.is_irreducible here
+        self.is_Field = self.domain.is_Field
+
+    def new(self, arg):
+        rep = self.ring.convert(arg)
+        return ExtElem(rep % self.mod, self)
+
+    def __eq__(self, other):
+        if not isinstance(other, FiniteExtension):
+            return False
+        return self.modulus == other.modulus
+
+    def __hash__(self):
+        return hash((self.__class__.__name__, self.modulus))
+
+    def __str__(self):
+        return "%s/(%s)" % (self.ring, self.modulus.as_expr())
+
+    __repr__ = __str__
+
+    def convert(self, f, base=None):
+        rep = self.ring.convert(f, base)
+        return ExtElem(rep % self.mod, self)
+
+    def convert_from(self, f, base):
+        rep = self.ring.convert(f, base)
+        return ExtElem(rep % self.mod, self)
+
+    def to_sympy(self, f):
+        return self.ring.to_sympy(f.rep)
+
+    def from_sympy(self, f):
+        return self.convert(f)
+
+    def set_domain(self, K):
+        mod = self.modulus.set_domain(K)
+        return self.__class__(mod)
+
+    def drop(self, *symbols):
+        if self.symbol in symbols:
+            raise GeneratorsError('Can not drop generator from FiniteExtension')
+        K = self.domain.drop(*symbols)
+        return self.set_domain(K)
+
+    def quo(self, f, g):
+        return self.exquo(f, g)
+
+    def exquo(self, f, g):
+        rep = self.ring.exquo(f.rep, g.rep)
+        return ExtElem(rep % self.mod, self)
+
+    def is_negative(self, a):
+        return False
+
+    def is_unit(self, a):
+        if self.is_Field:
+            return bool(a)
+        elif a.is_ground:
+            return self.domain.is_unit(a.to_ground())
+
+FiniteExtension = MonogenicFiniteExtension

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/homomorphisms.py

@@ -0,0 +1,691 @@
+"""
+Computations with homomorphisms of modules and rings.
+
+This module implements classes for representing homomorphisms of rings and
+their modules. Instead of instantiating the classes directly, you should use
+the function ``homomorphism(from, to, matrix)`` to create homomorphism objects.
+"""
+
+
+from sympy.polys.agca.modules import (Module, FreeModule, QuotientModule,
+    SubModule, SubQuotientModule)
+from sympy.polys.polyerrors import CoercionFailed
+
+# The main computational task for module homomorphisms is kernels.
+# For this reason, the concrete classes are organised by domain module type.
+
+
+class ModuleHomomorphism:
+    """
+    Abstract base class for module homomoprhisms. Do not instantiate.
+
+    Instead, use the ``homomorphism`` function:
+
+    >>> from sympy import QQ
+    >>> from sympy.abc import x
+    >>> from sympy.polys.agca import homomorphism
+
+    >>> F = QQ.old_poly_ring(x).free_module(2)
+    >>> homomorphism(F, F, [[1, 0], [0, 1]])
+    Matrix([
+    [1, 0], : QQ[x]**2 -> QQ[x]**2
+    [0, 1]])
+
+    Attributes:
+
+    - ring - the ring over which we are considering modules
+    - domain - the domain module
+    - codomain - the codomain module
+    - _ker - cached kernel
+    - _img - cached image
+
+    Non-implemented methods:
+
+    - _kernel
+    - _image
+    - _restrict_domain
+    - _restrict_codomain
+    - _quotient_domain
+    - _quotient_codomain
+    - _apply
+    - _mul_scalar
+    - _compose
+    - _add
+    """
+
+    def __init__(self, domain, codomain):
+        if not isinstance(domain, Module):
+            raise TypeError('Source must be a module, got %s' % domain)
+        if not isinstance(codomain, Module):
+            raise TypeError('Target must be a module, got %s' % codomain)
+        if domain.ring != codomain.ring:
+            raise ValueError('Source and codomain must be over same ring, '
+                             'got %s != %s' % (domain, codomain))
+        self.domain = domain
+        self.codomain = codomain
+        self.ring = domain.ring
+        self._ker = None
+        self._img = None
+
+    def kernel(self):
+        r"""
+        Compute the kernel of ``self``.
+
+        That is, if ``self`` is the homomorphism `\phi: M \to N`, then compute
+        `ker(\phi) = \{x \in M | \phi(x) = 0\}`.  This is a submodule of `M`.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> homomorphism(F, F, [[1, 0], [x, 0]]).kernel()
+        <[x, -1]>
+        """
+        if self._ker is None:
+            self._ker = self._kernel()
+        return self._ker
+
+    def image(self):
+        r"""
+        Compute the image of ``self``.
+
+        That is, if ``self`` is the homomorphism `\phi: M \to N`, then compute
+        `im(\phi) = \{\phi(x) | x \in M \}`.  This is a submodule of `N`.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> homomorphism(F, F, [[1, 0], [x, 0]]).image() == F.submodule([1, 0])
+        True
+        """
+        if self._img is None:
+            self._img = self._image()
+        return self._img
+
+    def _kernel(self):
+        """Compute the kernel of ``self``."""
+        raise NotImplementedError
+
+    def _image(self):
+        """Compute the image of ``self``."""
+        raise NotImplementedError
+
+    def _restrict_domain(self, sm):
+        """Implementation of domain restriction."""
+        raise NotImplementedError
+
+    def _restrict_codomain(self, sm):
+        """Implementation of codomain restriction."""
+        raise NotImplementedError
+
+    def _quotient_domain(self, sm):
+        """Implementation of domain quotient."""
+        raise NotImplementedError
+
+    def _quotient_codomain(self, sm):
+        """Implementation of codomain quotient."""
+        raise NotImplementedError
+
+    def restrict_domain(self, sm):
+        """
+        Return ``self``, with the domain restricted to ``sm``.
+
+        Here ``sm`` has to be a submodule of ``self.domain``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h
+        Matrix([
+        [1, x], : QQ[x]**2 -> QQ[x]**2
+        [0, 0]])
+        >>> h.restrict_domain(F.submodule([1, 0]))
+        Matrix([
+        [1, x], : <[1, 0]> -> QQ[x]**2
+        [0, 0]])
+
+        This is the same as just composing on the right with the submodule
+        inclusion:
+
+        >>> h * F.submodule([1, 0]).inclusion_hom()
+        Matrix([
+        [1, x], : <[1, 0]> -> QQ[x]**2
+        [0, 0]])
+        """
+        if not self.domain.is_submodule(sm):
+            raise ValueError('sm must be a submodule of %s, got %s'
+                             % (self.domain, sm))
+        if sm == self.domain:
+            return self
+        return self._restrict_domain(sm)
+
+    def restrict_codomain(self, sm):
+        """
+        Return ``self``, with codomain restricted to to ``sm``.
+
+        Here ``sm`` has to be a submodule of ``self.codomain`` containing the
+        image.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h
+        Matrix([
+        [1, x], : QQ[x]**2 -> QQ[x]**2
+        [0, 0]])
+        >>> h.restrict_codomain(F.submodule([1, 0]))
+        Matrix([
+        [1, x], : QQ[x]**2 -> <[1, 0]>
+        [0, 0]])
+        """
+        if not sm.is_submodule(self.image()):
+            raise ValueError('the image %s must contain sm, got %s'
+                             % (self.image(), sm))
+        if sm == self.codomain:
+            return self
+        return self._restrict_codomain(sm)
+
+    def quotient_domain(self, sm):
+        """
+        Return ``self`` with domain replaced by ``domain/sm``.
+
+        Here ``sm`` must be a submodule of ``self.kernel()``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h
+        Matrix([
+        [1, x], : QQ[x]**2 -> QQ[x]**2
+        [0, 0]])
+        >>> h.quotient_domain(F.submodule([-x, 1]))
+        Matrix([
+        [1, x], : QQ[x]**2/<[-x, 1]> -> QQ[x]**2
+        [0, 0]])
+        """
+        if not self.kernel().is_submodule(sm):
+            raise ValueError('kernel %s must contain sm, got %s' %
+                             (self.kernel(), sm))
+        if sm.is_zero():
+            return self
+        return self._quotient_domain(sm)
+
+    def quotient_codomain(self, sm):
+        """
+        Return ``self`` with codomain replaced by ``codomain/sm``.
+
+        Here ``sm`` must be a submodule of ``self.codomain``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h
+        Matrix([
+        [1, x], : QQ[x]**2 -> QQ[x]**2
+        [0, 0]])
+        >>> h.quotient_codomain(F.submodule([1, 1]))
+        Matrix([
+        [1, x], : QQ[x]**2 -> QQ[x]**2/<[1, 1]>
+        [0, 0]])
+
+        This is the same as composing with the quotient map on the left:
+
+        >>> (F/[(1, 1)]).quotient_hom() * h
+        Matrix([
+        [1, x], : QQ[x]**2 -> QQ[x]**2/<[1, 1]>
+        [0, 0]])
+        """
+        if not self.codomain.is_submodule(sm):
+            raise ValueError('sm must be a submodule of codomain %s, got %s'
+                             % (self.codomain, sm))
+        if sm.is_zero():
+            return self
+        return self._quotient_codomain(sm)
+
+    def _apply(self, elem):
+        """Apply ``self`` to ``elem``."""
+        raise NotImplementedError
+
+    def __call__(self, elem):
+        return self.codomain.convert(self._apply(self.domain.convert(elem)))
+
+    def _compose(self, oth):
+        """
+        Compose ``self`` with ``oth``, that is, return the homomorphism
+        obtained by first applying then ``self``, then ``oth``.
+
+        (This method is private since in this syntax, it is non-obvious which
+        homomorphism is executed first.)
+        """
+        raise NotImplementedError
+
+    def _mul_scalar(self, c):
+        """Scalar multiplication. ``c`` is guaranteed in self.ring."""
+        raise NotImplementedError
+
+    def _add(self, oth):
+        """
+        Homomorphism addition.
+        ``oth`` is guaranteed to be a homomorphism with same domain/codomain.
+        """
+        raise NotImplementedError
+
+    def _check_hom(self, oth):
+        """Helper to check that oth is a homomorphism with same domain/codomain."""
+        if not isinstance(oth, ModuleHomomorphism):
+            return False
+        return oth.domain == self.domain and oth.codomain == self.codomain
+
+    def __mul__(self, oth):
+        if isinstance(oth, ModuleHomomorphism) and self.domain == oth.codomain:
+            return oth._compose(self)
+        try:
+            return self._mul_scalar(self.ring.convert(oth))
+        except CoercionFailed:
+            return NotImplemented
+
+    # NOTE: _compose will never be called from rmul
+    __rmul__ = __mul__
+
+    def __truediv__(self, oth):
+        try:
+            return self._mul_scalar(1/self.ring.convert(oth))
+        except CoercionFailed:
+            return NotImplemented
+
+    def __add__(self, oth):
+        if self._check_hom(oth):
+            return self._add(oth)
+        return NotImplemented
+
+    def __sub__(self, oth):
+        if self._check_hom(oth):
+            return self._add(oth._mul_scalar(self.ring.convert(-1)))
+        return NotImplemented
+
+    def is_injective(self):
+        """
+        Return True if ``self`` is injective.
+
+        That is, check if the elements of the domain are mapped to the same
+        codomain element.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h.is_injective()
+        False
+        >>> h.quotient_domain(h.kernel()).is_injective()
+        True
+        """
+        return self.kernel().is_zero()
+
+    def is_surjective(self):
+        """
+        Return True if ``self`` is surjective.
+
+        That is, check if every element of the codomain has at least one
+        preimage.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h.is_surjective()
+        False
+        >>> h.restrict_codomain(h.image()).is_surjective()
+        True
+        """
+        return self.image() == self.codomain
+
+    def is_isomorphism(self):
+        """
+        Return True if ``self`` is an isomorphism.
+
+        That is, check if every element of the codomain has precisely one
+        preimage. Equivalently, ``self`` is both injective and surjective.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h = h.restrict_codomain(h.image())
+        >>> h.is_isomorphism()
+        False
+        >>> h.quotient_domain(h.kernel()).is_isomorphism()
+        True
+        """
+        return self.is_injective() and self.is_surjective()
+
+    def is_zero(self):
+        """
+        Return True if ``self`` is a zero morphism.
+
+        That is, check if every element of the domain is mapped to zero
+        under self.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x
+        >>> from sympy.polys.agca import homomorphism
+
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> h = homomorphism(F, F, [[1, 0], [x, 0]])
+        >>> h.is_zero()
+        False
+        >>> h.restrict_domain(F.submodule()).is_zero()
+        True
+        >>> h.quotient_codomain(h.image()).is_zero()
+        True
+        """
+        return self.image().is_zero()
+
+    def __eq__(self, oth):
+        try:
+            return (self - oth).is_zero()
+        except TypeError:
+            return False
+
+    def __ne__(self, oth):
+        return not (self == oth)
+
+
+class MatrixHomomorphism(ModuleHomomorphism):
+    r"""
+    Helper class for all homomoprhisms which are expressed via a matrix.
+
+    That is, for such homomorphisms ``domain`` is contained in a module
+    generated by finitely many elements `e_1, \ldots, e_n`, so that the
+    homomorphism is determined uniquely by its action on the `e_i`. It
+    can thus be represented as a vector of elements of the codomain module,
+    or potentially a supermodule of the codomain module
+    (and hence conventionally as a matrix, if there is a similar interpretation
+    for elements of the codomain module).
+
+    Note that this class does *not* assume that the `e_i` freely generate a
+    submodule, nor that ``domain`` is even all of this submodule. It exists
+    only to unify the interface.
+
+    Do not instantiate.
+
+    Attributes:
+
+    - matrix - the list of images determining the homomorphism.
+    NOTE: the elements of matrix belong to either self.codomain or
+          self.codomain.container
+
+    Still non-implemented methods:
+
+    - kernel
+    - _apply
+    """
+
+    def __init__(self, domain, codomain, matrix):
+        ModuleHomomorphism.__init__(self, domain, codomain)
+        if len(matrix) != domain.rank:
+            raise ValueError('Need to provide %s elements, got %s'
+                             % (domain.rank, len(matrix)))
+
+        converter = self.codomain.convert
+        if isinstance(self.codomain, (SubModule, SubQuotientModule)):
+            converter = self.codomain.container.convert
+        self.matrix = tuple(converter(x) for x in matrix)
+
+    def _sympy_matrix(self):
+        """Helper function which returns a SymPy matrix ``self.matrix``."""
+        from sympy.matrices import Matrix
+        c = lambda x: x
+        if isinstance(self.codomain, (QuotientModule, SubQuotientModule)):
+            c = lambda x: x.data
+        return Matrix([[self.ring.to_sympy(y) for y in c(x)] for x in self.matrix]).T
+
+    def __repr__(self):
+        lines = repr(self._sympy_matrix()).split('\n')
+        t = " : %s -> %s" % (self.domain, self.codomain)
+        s = ' '*len(t)
+        n = len(lines)
+        for i in range(n // 2):
+            lines[i] += s
+        lines[n // 2] += t
+        for i in range(n//2 + 1, n):
+            lines[i] += s
+        return '\n'.join(lines)
+
+    def _restrict_domain(self, sm):
+        """Implementation of domain restriction."""
+        return SubModuleHomomorphism(sm, self.codomain, self.matrix)
+
+    def _restrict_codomain(self, sm):
+        """Implementation of codomain restriction."""
+        return self.__class__(self.domain, sm, self.matrix)
+
+    def _quotient_domain(self, sm):
+        """Implementation of domain quotient."""
+        return self.__class__(self.domain/sm, self.codomain, self.matrix)
+
+    def _quotient_codomain(self, sm):
+        """Implementation of codomain quotient."""
+        Q = self.codomain/sm
+        converter = Q.convert
+        if isinstance(self.codomain, SubModule):
+            converter = Q.container.convert
+        return self.__class__(self.domain, self.codomain/sm,
+            [converter(x) for x in self.matrix])
+
+    def _add(self, oth):
+        return self.__class__(self.domain, self.codomain,
+                              [x + y for x, y in zip(self.matrix, oth.matrix)])
+
+    def _mul_scalar(self, c):
+        return self.__class__(self.domain, self.codomain, [c*x for x in self.matrix])
+
+    def _compose(self, oth):
+        return self.__class__(self.domain, oth.codomain, [oth(x) for x in self.matrix])
+
+
+class FreeModuleHomomorphism(MatrixHomomorphism):
+    """
+    Concrete class for homomorphisms with domain a free module or a quotient
+    thereof.
+
+    Do not instantiate; the constructor does not check that your data is well
+    defined. Use the ``homomorphism`` function instead:
+
+    >>> from sympy import QQ
+    >>> from sympy.abc import x
+    >>> from sympy.polys.agca import homomorphism
+
+    >>> F = QQ.old_poly_ring(x).free_module(2)
+    >>> homomorphism(F, F, [[1, 0], [0, 1]])
+    Matrix([
+    [1, 0], : QQ[x]**2 -> QQ[x]**2
+    [0, 1]])
+    """
+
+    def _apply(self, elem):
+        if isinstance(self.domain, QuotientModule):
+            elem = elem.data
+        return sum(x * e for x, e in zip(elem, self.matrix))
+
+    def _image(self):
+        return self.codomain.submodule(*self.matrix)
+
+    def _kernel(self):
+        # The domain is either a free module or a quotient thereof.
+        # It does not matter if it is a quotient, because that won't increase
+        # the kernel.
+        # Our generators {e_i} are sent to the matrix entries {b_i}.
+        # The kernel is essentially the syzygy module of these {b_i}.
+        syz = self.image().syzygy_module()
+        return self.domain.submodule(*syz.gens)
+
+
+class SubModuleHomomorphism(MatrixHomomorphism):
+    """
+    Concrete class for homomorphism with domain a submodule of a free module
+    or a quotient thereof.
+
+    Do not instantiate; the constructor does not check that your data is well
+    defined. Use the ``homomorphism`` function instead:
+
+    >>> from sympy import QQ
+    >>> from sympy.abc import x
+    >>> from sympy.polys.agca import homomorphism
+
+    >>> M = QQ.old_poly_ring(x).free_module(2)*x
+    >>> homomorphism(M, M, [[1, 0], [0, 1]])
+    Matrix([
+    [1, 0], : <[x, 0], [0, x]> -> <[x, 0], [0, x]>
+    [0, 1]])
+    """
+
+    def _apply(self, elem):
+        if isinstance(self.domain, SubQuotientModule):
+            elem = elem.data
+        return sum(x * e for x, e in zip(elem, self.matrix))
+
+    def _image(self):
+        return self.codomain.submodule(*[self(x) for x in self.domain.gens])
+
+    def _kernel(self):
+        syz = self.image().syzygy_module()
+        return self.domain.submodule(
+            *[sum(xi*gi for xi, gi in zip(s, self.domain.gens))
+              for s in syz.gens])
+
+
+def homomorphism(domain, codomain, matrix):
+    r"""
+    Create a homomorphism object.
+
+    This function tries to build a homomorphism from ``domain`` to ``codomain``
+    via the matrix ``matrix``.
+
+    Examples
+    ========
+
+    >>> from sympy import QQ
+    >>> from sympy.abc import x
+    >>> from sympy.polys.agca import homomorphism
+
+    >>> R = QQ.old_poly_ring(x)
+    >>> T = R.free_module(2)
+
+    If ``domain`` is a free module generated by `e_1, \ldots, e_n`, then
+    ``matrix`` should be an n-element iterable `(b_1, \ldots, b_n)` where
+    the `b_i` are elements of ``codomain``. The constructed homomorphism is the
+    unique homomorphism sending `e_i` to `b_i`.
+
+    >>> F = R.free_module(2)
+    >>> h = homomorphism(F, T, [[1, x], [x**2, 0]])
+    >>> h
+    Matrix([
+    [1, x**2], : QQ[x]**2 -> QQ[x]**2
+    [x,    0]])
+    >>> h([1, 0])
+    [1, x]
+    >>> h([0, 1])
+    [x**2, 0]
+    >>> h([1, 1])
+    [x**2 + 1, x]
+
+    If ``domain`` is a submodule of a free module, them ``matrix`` determines
+    a homomoprhism from the containing free module to ``codomain``, and the
+    homomorphism returned is obtained by restriction to ``domain``.
+
+    >>> S = F.submodule([1, 0], [0, x])
+    >>> homomorphism(S, T, [[1, x], [x**2, 0]])
+    Matrix([
+    [1, x**2], : <[1, 0], [0, x]> -> QQ[x]**2
+    [x,    0]])
+
+    If ``domain`` is a (sub)quotient `N/K`, then ``matrix`` determines a
+    homomorphism from `N` to ``codomain``. If the kernel contains `K`, this
+    homomorphism descends to ``domain`` and is returned; otherwise an exception
+    is raised.
+
+    >>> homomorphism(S/[(1, 0)], T, [0, [x**2, 0]])
+    Matrix([
+    [0, x**2], : <[1, 0] + <[1, 0]>, [0, x] + <[1, 0]>, [1, 0] + <[1, 0]>> -> QQ[x]**2
+    [0,    0]])
+    >>> homomorphism(S/[(0, x)], T, [0, [x**2, 0]])
+    Traceback (most recent call last):
+    ...
+    ValueError: kernel <[1, 0], [0, 0]> must contain sm, got <[0,x]>
+
+    """
+    def freepres(module):
+        """
+        Return a tuple ``(F, S, Q, c)`` where ``F`` is a free module, ``S`` is a
+        submodule of ``F``, and ``Q`` a submodule of ``S``, such that
+        ``module = S/Q``, and ``c`` is a conversion function.
+        """
+        if isinstance(module, FreeModule):
+            return module, module, module.submodule(), lambda x: module.convert(x)
+        if isinstance(module, QuotientModule):
+            return (module.base, module.base, module.killed_module,
+                    lambda x: module.convert(x).data)
+        if isinstance(module, SubQuotientModule):
+            return (module.base.container, module.base, module.killed_module,
+                    lambda x: module.container.convert(x).data)
+        # an ordinary submodule
+        return (module.container, module, module.submodule(),
+                lambda x: module.container.convert(x))
+
+    SF, SS, SQ, _ = freepres(domain)
+    TF, TS, TQ, c = freepres(codomain)
+    # NOTE this is probably a bit inefficient (redundant checks)
+    return FreeModuleHomomorphism(SF, TF, [c(x) for x in matrix]
+         ).restrict_domain(SS).restrict_codomain(TS
+         ).quotient_codomain(TQ).quotient_domain(SQ)

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/ideals.py

@@ -0,0 +1,394 @@
+"""Computations with ideals of polynomial rings."""
+
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.polys.polyutils import IntegerPowerable
+
+
+class Ideal(IntegerPowerable):
+    """
+    Abstract base class for ideals.
+
+    Do not instantiate - use explicit constructors in the ring class instead:
+
+    >>> from sympy import QQ
+    >>> from sympy.abc import x
+    >>> QQ.old_poly_ring(x).ideal(x+1)
+    <x + 1>
+
+    Attributes
+
+    - ring - the ring this ideal belongs to
+
+    Non-implemented methods:
+
+    - _contains_elem
+    - _contains_ideal
+    - _quotient
+    - _intersect
+    - _union
+    - _product
+    - is_whole_ring
+    - is_zero
+    - is_prime, is_maximal, is_primary, is_radical
+    - is_principal
+    - height, depth
+    - radical
+
+    Methods that likely should be overridden in subclasses:
+
+    - reduce_element
+    """
+
+    def _contains_elem(self, x):
+        """Implementation of element containment."""
+        raise NotImplementedError
+
+    def _contains_ideal(self, I):
+        """Implementation of ideal containment."""
+        raise NotImplementedError
+
+    def _quotient(self, J):
+        """Implementation of ideal quotient."""
+        raise NotImplementedError
+
+    def _intersect(self, J):
+        """Implementation of ideal intersection."""
+        raise NotImplementedError
+
+    def is_whole_ring(self):
+        """Return True if ``self`` is the whole ring."""
+        raise NotImplementedError
+
+    def is_zero(self):
+        """Return True if ``self`` is the zero ideal."""
+        raise NotImplementedError
+
+    def _equals(self, J):
+        """Implementation of ideal equality."""
+        return self._contains_ideal(J) and J._contains_ideal(self)
+
+    def is_prime(self):
+        """Return True if ``self`` is a prime ideal."""
+        raise NotImplementedError
+
+    def is_maximal(self):
+        """Return True if ``self`` is a maximal ideal."""
+        raise NotImplementedError
+
+    def is_radical(self):
+        """Return True if ``self`` is a radical ideal."""
+        raise NotImplementedError
+
+    def is_primary(self):
+        """Return True if ``self`` is a primary ideal."""
+        raise NotImplementedError
+
+    def is_principal(self):
+        """Return True if ``self`` is a principal ideal."""
+        raise NotImplementedError
+
+    def radical(self):
+        """Compute the radical of ``self``."""
+        raise NotImplementedError
+
+    def depth(self):
+        """Compute the depth of ``self``."""
+        raise NotImplementedError
+
+    def height(self):
+        """Compute the height of ``self``."""
+        raise NotImplementedError
+
+    # TODO more
+
+    # non-implemented methods end here
+
+    def __init__(self, ring):
+        self.ring = ring
+
+    def _check_ideal(self, J):
+        """Helper to check ``J`` is an ideal of our ring."""
+        if not isinstance(J, Ideal) or J.ring != self.ring:
+            raise ValueError(
+                'J must be an ideal of %s, got %s' % (self.ring, J))
+
+    def contains(self, elem):
+        """
+        Return True if ``elem`` is an element of this ideal.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).ideal(x+1, x-1).contains(3)
+        True
+        >>> QQ.old_poly_ring(x).ideal(x**2, x**3).contains(x)
+        False
+        """
+        return self._contains_elem(self.ring.convert(elem))
+
+    def subset(self, other):
+        """
+        Returns True if ``other`` is is a subset of ``self``.
+
+        Here ``other`` may be an ideal.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> I = QQ.old_poly_ring(x).ideal(x+1)
+        >>> I.subset([x**2 - 1, x**2 + 2*x + 1])
+        True
+        >>> I.subset([x**2 + 1, x + 1])
+        False
+        >>> I.subset(QQ.old_poly_ring(x).ideal(x**2 - 1))
+        True
+        """
+        if isinstance(other, Ideal):
+            return self._contains_ideal(other)
+        return all(self._contains_elem(x) for x in other)
+
+    def quotient(self, J, **opts):
+        r"""
+        Compute the ideal quotient of ``self`` by ``J``.
+
+        That is, if ``self`` is the ideal `I`, compute the set
+        `I : J = \{x \in R | xJ \subset I \}`.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> R = QQ.old_poly_ring(x, y)
+        >>> R.ideal(x*y).quotient(R.ideal(x))
+        <y>
+        """
+        self._check_ideal(J)
+        return self._quotient(J, **opts)
+
+    def intersect(self, J):
+        """
+        Compute the intersection of self with ideal J.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> R = QQ.old_poly_ring(x, y)
+        >>> R.ideal(x).intersect(R.ideal(y))
+        <x*y>
+        """
+        self._check_ideal(J)
+        return self._intersect(J)
+
+    def saturate(self, J):
+        r"""
+        Compute the ideal saturation of ``self`` by ``J``.
+
+        That is, if ``self`` is the ideal `I`, compute the set
+        `I : J^\infty = \{x \in R | xJ^n \subset I \text{ for some } n\}`.
+        """
+        raise NotImplementedError
+        # Note this can be implemented using repeated quotient
+
+    def union(self, J):
+        """
+        Compute the ideal generated by the union of ``self`` and ``J``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).ideal(x**2 - 1).union(QQ.old_poly_ring(x).ideal((x+1)**2)) == QQ.old_poly_ring(x).ideal(x+1)
+        True
+        """
+        self._check_ideal(J)
+        return self._union(J)
+
+    def product(self, J):
+        r"""
+        Compute the ideal product of ``self`` and ``J``.
+
+        That is, compute the ideal generated by products `xy`, for `x` an element
+        of ``self`` and `y \in J`.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x, y).ideal(x).product(QQ.old_poly_ring(x, y).ideal(y))
+        <x*y>
+        """
+        self._check_ideal(J)
+        return self._product(J)
+
+    def reduce_element(self, x):
+        """
+        Reduce the element ``x`` of our ring modulo the ideal ``self``.
+
+        Here "reduce" has no specific meaning: it could return a unique normal
+        form, simplify the expression a bit, or just do nothing.
+        """
+        return x
+
+    def __add__(self, e):
+        if not isinstance(e, Ideal):
+            R = self.ring.quotient_ring(self)
+            if isinstance(e, R.dtype):
+                return e
+            if isinstance(e, R.ring.dtype):
+                return R(e)
+            return R.convert(e)
+        self._check_ideal(e)
+        return self.union(e)
+
+    __radd__ = __add__
+
+    def __mul__(self, e):
+        if not isinstance(e, Ideal):
+            try:
+                e = self.ring.ideal(e)
+            except CoercionFailed:
+                return NotImplemented
+        self._check_ideal(e)
+        return self.product(e)
+
+    __rmul__ = __mul__
+
+    def _zeroth_power(self):
+        return self.ring.ideal(1)
+
+    def _first_power(self):
+        # Raising to any power but 1 returns a new instance. So we mult by 1
+        # here so that the first power is no exception.
+        return self * 1
+
+    def __eq__(self, e):
+        if not isinstance(e, Ideal) or e.ring != self.ring:
+            return False
+        return self._equals(e)
+
+    def __ne__(self, e):
+        return not (self == e)
+
+
+class ModuleImplementedIdeal(Ideal):
+    """
+    Ideal implementation relying on the modules code.
+
+    Attributes:
+
+    - _module - the underlying module
+    """
+
+    def __init__(self, ring, module):
+        Ideal.__init__(self, ring)
+        self._module = module
+
+    def _contains_elem(self, x):
+        return self._module.contains([x])
+
+    def _contains_ideal(self, J):
+        if not isinstance(J, ModuleImplementedIdeal):
+            raise NotImplementedError
+        return self._module.is_submodule(J._module)
+
+    def _intersect(self, J):
+        if not isinstance(J, ModuleImplementedIdeal):
+            raise NotImplementedError
+        return self.__class__(self.ring, self._module.intersect(J._module))
+
+    def _quotient(self, J, **opts):
+        if not isinstance(J, ModuleImplementedIdeal):
+            raise NotImplementedError
+        return self._module.module_quotient(J._module, **opts)
+
+    def _union(self, J):
+        if not isinstance(J, ModuleImplementedIdeal):
+            raise NotImplementedError
+        return self.__class__(self.ring, self._module.union(J._module))
+
+    @property
+    def gens(self):
+        """
+        Return generators for ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x, y
+        >>> list(QQ.old_poly_ring(x, y).ideal(x, y, x**2 + y).gens)
+        [x, y, x**2 + y]
+        """
+        return (x[0] for x in self._module.gens)
+
+    def is_zero(self):
+        """
+        Return True if ``self`` is the zero ideal.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).ideal(x).is_zero()
+        False
+        >>> QQ.old_poly_ring(x).ideal().is_zero()
+        True
+        """
+        return self._module.is_zero()
+
+    def is_whole_ring(self):
+        """
+        Return True if ``self`` is the whole ring, i.e. one generator is a unit.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ, ilex
+        >>> QQ.old_poly_ring(x).ideal(x).is_whole_ring()
+        False
+        >>> QQ.old_poly_ring(x).ideal(3).is_whole_ring()
+        True
+        >>> QQ.old_poly_ring(x, order=ilex).ideal(2 + x).is_whole_ring()
+        True
+        """
+        return self._module.is_full_module()
+
+    def __repr__(self):
+        from sympy.printing.str import sstr
+        return '<' + ','.join(sstr(x) for [x] in self._module.gens) + '>'
+
+    # NOTE this is the only method using the fact that the module is a SubModule
+    def _product(self, J):
+        if not isinstance(J, ModuleImplementedIdeal):
+            raise NotImplementedError
+        return self.__class__(self.ring, self._module.submodule(
+            *[[x*y] for [x] in self._module.gens for [y] in J._module.gens]))
+
+    def in_terms_of_generators(self, e):
+        """
+        Express ``e`` in terms of the generators of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> I = QQ.old_poly_ring(x).ideal(x**2 + 1, x)
+        >>> I.in_terms_of_generators(1)
+        [1, -x]
+        """
+        return self._module.in_terms_of_generators([e])
+
+    def reduce_element(self, x, **options):
+        return self._module.reduce_element([x], **options)[0]

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/modules.py

@@ -0,0 +1,1484 @@
+"""
+Computations with modules over polynomial rings.
+
+This module implements various classes that encapsulate groebner basis
+computations for modules. Most of them should not be instantiated by hand.
+Instead, use the constructing routines on objects you already have.
+
+For example, to construct a free module over ``QQ[x, y]``, call
+``QQ[x, y].free_module(rank)`` instead of the ``FreeModule`` constructor.
+In fact ``FreeModule`` is an abstract base class that should not be
+instantiated, the ``free_module`` method instead returns the implementing class
+``FreeModulePolyRing``.
+
+In general, the abstract base classes implement most functionality in terms of
+a few non-implemented methods. The concrete base classes supply only these
+non-implemented methods. They may also supply new implementations of the
+convenience methods, for example if there are faster algorithms available.
+"""
+
+
+from copy import copy
+from functools import reduce
+
+from sympy.polys.agca.ideals import Ideal
+from sympy.polys.domains.field import Field
+from sympy.polys.orderings import ProductOrder, monomial_key
+from sympy.polys.polyerrors import CoercionFailed
+from sympy.core.basic import _aresame
+from sympy.utilities.iterables import iterable
+
+# TODO
+# - module saturation
+# - module quotient/intersection for quotient rings
+# - free resoltutions / syzygies
+# - finding small/minimal generating sets
+# - ...
+
+##########################################################################
+## Abstract base classes #################################################
+##########################################################################
+
+
+class Module:
+    """
+    Abstract base class for modules.
+
+    Do not instantiate - use ring explicit constructors instead:
+
+    >>> from sympy import QQ
+    >>> from sympy.abc import x
+    >>> QQ.old_poly_ring(x).free_module(2)
+    QQ[x]**2
+
+    Attributes:
+
+    - dtype - type of elements
+    - ring - containing ring
+
+    Non-implemented methods:
+
+    - submodule
+    - quotient_module
+    - is_zero
+    - is_submodule
+    - multiply_ideal
+
+    The method convert likely needs to be changed in subclasses.
+    """
+
+    def __init__(self, ring):
+        self.ring = ring
+
+    def convert(self, elem, M=None):
+        """
+        Convert ``elem`` into internal representation of this module.
+
+        If ``M`` is not None, it should be a module containing it.
+        """
+        if not isinstance(elem, self.dtype):
+            raise CoercionFailed
+        return elem
+
+    def submodule(self, *gens):
+        """Generate a submodule."""
+        raise NotImplementedError
+
+    def quotient_module(self, other):
+        """Generate a quotient module."""
+        raise NotImplementedError
+
+    def __truediv__(self, e):
+        if not isinstance(e, Module):
+            e = self.submodule(*e)
+        return self.quotient_module(e)
+
+    def contains(self, elem):
+        """Return True if ``elem`` is an element of this module."""
+        try:
+            self.convert(elem)
+            return True
+        except CoercionFailed:
+            return False
+
+    def __contains__(self, elem):
+        return self.contains(elem)
+
+    def subset(self, other):
+        """
+        Returns True if ``other`` is is a subset of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> F.subset([(1, x), (x, 2)])
+        True
+        >>> F.subset([(1/x, x), (x, 2)])
+        False
+        """
+        return all(self.contains(x) for x in other)
+
+    def __eq__(self, other):
+        return self.is_submodule(other) and other.is_submodule(self)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def is_zero(self):
+        """Returns True if ``self`` is a zero module."""
+        raise NotImplementedError
+
+    def is_submodule(self, other):
+        """Returns True if ``other`` is a submodule of ``self``."""
+        raise NotImplementedError
+
+    def multiply_ideal(self, other):
+        """
+        Multiply ``self`` by the ideal ``other``.
+        """
+        raise NotImplementedError
+
+    def __mul__(self, e):
+        if not isinstance(e, Ideal):
+            try:
+                e = self.ring.ideal(e)
+            except (CoercionFailed, NotImplementedError):
+                return NotImplemented
+        return self.multiply_ideal(e)
+
+    __rmul__ = __mul__
+
+    def identity_hom(self):
+        """Return the identity homomorphism on ``self``."""
+        raise NotImplementedError
+
+
+class ModuleElement:
+    """
+    Base class for module element wrappers.
+
+    Use this class to wrap primitive data types as module elements. It stores
+    a reference to the containing module, and implements all the arithmetic
+    operators.
+
+    Attributes:
+
+    - module - containing module
+    - data - internal data
+
+    Methods that likely need change in subclasses:
+
+    - add
+    - mul
+    - div
+    - eq
+    """
+
+    def __init__(self, module, data):
+        self.module = module
+        self.data = data
+
+    def add(self, d1, d2):
+        """Add data ``d1`` and ``d2``."""
+        return d1 + d2
+
+    def mul(self, m, d):
+        """Multiply module data ``m`` by coefficient d."""
+        return m * d
+
+    def div(self, m, d):
+        """Divide module data ``m`` by coefficient d."""
+        return m / d
+
+    def eq(self, d1, d2):
+        """Return true if d1 and d2 represent the same element."""
+        return d1 == d2
+
+    def __add__(self, om):
+        if not isinstance(om, self.__class__) or om.module != self.module:
+            try:
+                om = self.module.convert(om)
+            except CoercionFailed:
+                return NotImplemented
+        return self.__class__(self.module, self.add(self.data, om.data))
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return self.__class__(self.module, self.mul(self.data,
+                       self.module.ring.convert(-1)))
+
+    def __sub__(self, om):
+        if not isinstance(om, self.__class__) or om.module != self.module:
+            try:
+                om = self.module.convert(om)
+            except CoercionFailed:
+                return NotImplemented
+        return self.__add__(-om)
+
+    def __rsub__(self, om):
+        return (-self).__add__(om)
+
+    def __mul__(self, o):
+        if not isinstance(o, self.module.ring.dtype):
+            try:
+                o = self.module.ring.convert(o)
+            except CoercionFailed:
+                return NotImplemented
+        return self.__class__(self.module, self.mul(self.data, o))
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, o):
+        if not isinstance(o, self.module.ring.dtype):
+            try:
+                o = self.module.ring.convert(o)
+            except CoercionFailed:
+                return NotImplemented
+        return self.__class__(self.module, self.div(self.data, o))
+
+    def __eq__(self, om):
+        if not isinstance(om, self.__class__) or om.module != self.module:
+            try:
+                om = self.module.convert(om)
+            except CoercionFailed:
+                return False
+        return self.eq(self.data, om.data)
+
+    def __ne__(self, om):
+        return not self == om
+
+##########################################################################
+## Free Modules ##########################################################
+##########################################################################
+
+
+class FreeModuleElement(ModuleElement):
+    """Element of a free module. Data stored as a tuple."""
+
+    def add(self, d1, d2):
+        return tuple(x + y for x, y in zip(d1, d2))
+
+    def mul(self, d, p):
+        return tuple(x * p for x in d)
+
+    def div(self, d, p):
+        return tuple(x / p for x in d)
+
+    def __repr__(self):
+        from sympy.printing.str import sstr
+        return '[' + ', '.join(sstr(x) for x in self.data) + ']'
+
+    def __iter__(self):
+        return self.data.__iter__()
+
+    def __getitem__(self, idx):
+        return self.data[idx]
+
+
+class FreeModule(Module):
+    """
+    Abstract base class for free modules.
+
+    Additional attributes:
+
+    - rank - rank of the free module
+
+    Non-implemented methods:
+
+    - submodule
+    """
+
+    dtype = FreeModuleElement
+
+    def __init__(self, ring, rank):
+        Module.__init__(self, ring)
+        self.rank = rank
+
+    def __repr__(self):
+        return repr(self.ring) + "**" + repr(self.rank)
+
+    def is_submodule(self, other):
+        """
+        Returns True if ``other`` is a submodule of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> M = F.submodule([2, x])
+        >>> F.is_submodule(F)
+        True
+        >>> F.is_submodule(M)
+        True
+        >>> M.is_submodule(F)
+        False
+        """
+        if isinstance(other, SubModule):
+            return other.container == self
+        if isinstance(other, FreeModule):
+            return other.ring == self.ring and other.rank == self.rank
+        return False
+
+    def convert(self, elem, M=None):
+        """
+        Convert ``elem`` into the internal representation.
+
+        This method is called implicitly whenever computations involve elements
+        not in the internal representation.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> F.convert([1, 0])
+        [1, 0]
+        """
+        if isinstance(elem, FreeModuleElement):
+            if elem.module is self:
+                return elem
+            if elem.module.rank != self.rank:
+                raise CoercionFailed
+            return FreeModuleElement(self,
+                     tuple(self.ring.convert(x, elem.module.ring) for x in elem.data))
+        elif iterable(elem):
+            tpl = tuple(self.ring.convert(x) for x in elem)
+            if len(tpl) != self.rank:
+                raise CoercionFailed
+            return FreeModuleElement(self, tpl)
+        elif _aresame(elem, 0):
+            return FreeModuleElement(self, (self.ring.convert(0),)*self.rank)
+        else:
+            raise CoercionFailed
+
+    def is_zero(self):
+        """
+        Returns True if ``self`` is a zero module.
+
+        (If, as this implementation assumes, the coefficient ring is not the
+        zero ring, then this is equivalent to the rank being zero.)
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(0).is_zero()
+        True
+        >>> QQ.old_poly_ring(x).free_module(1).is_zero()
+        False
+        """
+        return self.rank == 0
+
+    def basis(self):
+        """
+        Return a set of basis elements.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(3).basis()
+        ([1, 0, 0], [0, 1, 0], [0, 0, 1])
+        """
+        from sympy.matrices import eye
+        M = eye(self.rank)
+        return tuple(self.convert(M.row(i)) for i in range(self.rank))
+
+    def quotient_module(self, submodule):
+        """
+        Return a quotient module.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> M = QQ.old_poly_ring(x).free_module(2)
+        >>> M.quotient_module(M.submodule([1, x], [x, 2]))
+        QQ[x]**2/<[1, x], [x, 2]>
+
+        Or more conicisely, using the overloaded division operator:
+
+        >>> QQ.old_poly_ring(x).free_module(2) / [[1, x], [x, 2]]
+        QQ[x]**2/<[1, x], [x, 2]>
+        """
+        return QuotientModule(self.ring, self, submodule)
+
+    def multiply_ideal(self, other):
+        """
+        Multiply ``self`` by the ideal ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> I = QQ.old_poly_ring(x).ideal(x)
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> F.multiply_ideal(I)
+        <[x, 0], [0, x]>
+        """
+        return self.submodule(*self.basis()).multiply_ideal(other)
+
+    def identity_hom(self):
+        """
+        Return the identity homomorphism on ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(2).identity_hom()
+        Matrix([
+        [1, 0], : QQ[x]**2 -> QQ[x]**2
+        [0, 1]])
+        """
+        from sympy.polys.agca.homomorphisms import homomorphism
+        return homomorphism(self, self, self.basis())
+
+
+class FreeModulePolyRing(FreeModule):
+    """
+    Free module over a generalized polynomial ring.
+
+    Do not instantiate this, use the constructor method of the ring instead:
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy import QQ
+    >>> F = QQ.old_poly_ring(x).free_module(3)
+    >>> F
+    QQ[x]**3
+    >>> F.contains([x, 1, 0])
+    True
+    >>> F.contains([1/x, 0, 1])
+    False
+    """
+
+    def __init__(self, ring, rank):
+        from sympy.polys.domains.old_polynomialring import PolynomialRingBase
+        FreeModule.__init__(self, ring, rank)
+        if not isinstance(ring, PolynomialRingBase):
+            raise NotImplementedError('This implementation only works over '
+                                      + 'polynomial rings, got %s' % ring)
+        if not isinstance(ring.dom, Field):
+            raise NotImplementedError('Ground domain must be a field, '
+                                      + 'got %s' % ring.dom)
+
+    def submodule(self, *gens, **opts):
+        """
+        Generate a submodule.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> M = QQ.old_poly_ring(x, y).free_module(2).submodule([x, x + y])
+        >>> M
+        <[x, x + y]>
+        >>> M.contains([2*x, 2*x + 2*y])
+        True
+        >>> M.contains([x, y])
+        False
+        """
+        return SubModulePolyRing(gens, self, **opts)
+
+
+class FreeModuleQuotientRing(FreeModule):
+    """
+    Free module over a quotient ring.
+
+    Do not instantiate this, use the constructor method of the ring instead:
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy import QQ
+    >>> F = (QQ.old_poly_ring(x)/[x**2 + 1]).free_module(3)
+    >>> F
+    (QQ[x]/<x**2 + 1>)**3
+
+    Attributes
+
+    - quot - the quotient module `R^n / IR^n`, where `R/I` is our ring
+    """
+
+    def __init__(self, ring, rank):
+        from sympy.polys.domains.quotientring import QuotientRing
+        FreeModule.__init__(self, ring, rank)
+        if not isinstance(ring, QuotientRing):
+            raise NotImplementedError('This implementation only works over '
+                             + 'quotient rings, got %s' % ring)
+        F = self.ring.ring.free_module(self.rank)
+        self.quot = F / (self.ring.base_ideal*F)
+
+    def __repr__(self):
+        return "(" + repr(self.ring) + ")" + "**" + repr(self.rank)
+
+    def submodule(self, *gens, **opts):
+        """
+        Generate a submodule.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> M = (QQ.old_poly_ring(x, y)/[x**2 - y**2]).free_module(2).submodule([x, x + y])
+        >>> M
+        <[x + <x**2 - y**2>, x + y + <x**2 - y**2>]>
+        >>> M.contains([y**2, x**2 + x*y])
+        True
+        >>> M.contains([x, y])
+        False
+        """
+        return SubModuleQuotientRing(gens, self, **opts)
+
+    def lift(self, elem):
+        """
+        Lift the element ``elem`` of self to the module self.quot.
+
+        Note that self.quot is the same set as self, just as an R-module
+        and not as an R/I-module, so this makes sense.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = (QQ.old_poly_ring(x)/[x**2 + 1]).free_module(2)
+        >>> e = F.convert([1, 0])
+        >>> e
+        [1 + <x**2 + 1>, 0 + <x**2 + 1>]
+        >>> L = F.quot
+        >>> l = F.lift(e)
+        >>> l
+        [1, 0] + <[x**2 + 1, 0], [0, x**2 + 1]>
+        >>> L.contains(l)
+        True
+        """
+        return self.quot.convert([x.data for x in elem])
+
+    def unlift(self, elem):
+        """
+        Push down an element of self.quot to self.
+
+        This undoes ``lift``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = (QQ.old_poly_ring(x)/[x**2 + 1]).free_module(2)
+        >>> e = F.convert([1, 0])
+        >>> l = F.lift(e)
+        >>> e == l
+        False
+        >>> e == F.unlift(l)
+        True
+        """
+        return self.convert(elem.data)
+
+##########################################################################
+## Submodules and subquotients ###########################################
+##########################################################################
+
+
+class SubModule(Module):
+    """
+    Base class for submodules.
+
+    Attributes:
+
+    - container - containing module
+    - gens - generators (subset of containing module)
+    - rank - rank of containing module
+
+    Non-implemented methods:
+
+    - _contains
+    - _syzygies
+    - _in_terms_of_generators
+    - _intersect
+    - _module_quotient
+
+    Methods that likely need change in subclasses:
+
+    - reduce_element
+    """
+
+    def __init__(self, gens, container):
+        Module.__init__(self, container.ring)
+        self.gens = tuple(container.convert(x) for x in gens)
+        self.container = container
+        self.rank = container.rank
+        self.ring = container.ring
+        self.dtype = container.dtype
+
+    def __repr__(self):
+        return "<" + ", ".join(repr(x) for x in self.gens) + ">"
+
+    def _contains(self, other):
+        """Implementation of containment.
+           Other is guaranteed to be FreeModuleElement."""
+        raise NotImplementedError
+
+    def _syzygies(self):
+        """Implementation of syzygy computation wrt self generators."""
+        raise NotImplementedError
+
+    def _in_terms_of_generators(self, e):
+        """Implementation of expression in terms of generators."""
+        raise NotImplementedError
+
+    def convert(self, elem, M=None):
+        """
+        Convert ``elem`` into the internal represantition.
+
+        Mostly called implicitly.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> M = QQ.old_poly_ring(x).free_module(2).submodule([1, x])
+        >>> M.convert([2, 2*x])
+        [2, 2*x]
+        """
+        if isinstance(elem, self.container.dtype) and elem.module is self:
+            return elem
+        r = copy(self.container.convert(elem, M))
+        r.module = self
+        if not self._contains(r):
+            raise CoercionFailed
+        return r
+
+    def _intersect(self, other):
+        """Implementation of intersection.
+           Other is guaranteed to be a submodule of same free module."""
+        raise NotImplementedError
+
+    def _module_quotient(self, other):
+        """Implementation of quotient.
+           Other is guaranteed to be a submodule of same free module."""
+        raise NotImplementedError
+
+    def intersect(self, other, **options):
+        """
+        Returns the intersection of ``self`` with submodule ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x, y).free_module(2)
+        >>> F.submodule([x, x]).intersect(F.submodule([y, y]))
+        <[x*y, x*y]>
+
+        Some implementation allow further options to be passed. Currently, to
+        only one implemented is ``relations=True``, in which case the function
+        will return a triple ``(res, rela, relb)``, where ``res`` is the
+        intersection module, and ``rela`` and ``relb`` are lists of coefficient
+        vectors, expressing the generators of ``res`` in terms of the
+        generators of ``self`` (``rela``) and ``other`` (``relb``).
+
+        >>> F.submodule([x, x]).intersect(F.submodule([y, y]), relations=True)
+        (<[x*y, x*y]>, [(y,)], [(x,)])
+
+        The above result says: the intersection module is generated by the
+        single element `(-xy, -xy) = -y (x, x) = -x (y, y)`, where
+        `(x, x)` and `(y, y)` respectively are the unique generators of
+        the two modules being intersected.
+        """
+        if not isinstance(other, SubModule):
+            raise TypeError('%s is not a SubModule' % other)
+        if other.container != self.container:
+            raise ValueError(
+                '%s is contained in a different free module' % other)
+        return self._intersect(other, **options)
+
+    def module_quotient(self, other, **options):
+        r"""
+        Returns the module quotient of ``self`` by submodule ``other``.
+
+        That is, if ``self`` is the module `M` and ``other`` is `N`, then
+        return the ideal `\{f \in R | fN \subset M\}`.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.abc import x, y
+        >>> F = QQ.old_poly_ring(x, y).free_module(2)
+        >>> S = F.submodule([x*y, x*y])
+        >>> T = F.submodule([x, x])
+        >>> S.module_quotient(T)
+        <y>
+
+        Some implementations allow further options to be passed. Currently, the
+        only one implemented is ``relations=True``, which may only be passed
+        if ``other`` is principal. In this case the function
+        will return a pair ``(res, rel)`` where ``res`` is the ideal, and
+        ``rel`` is a list of coefficient vectors, expressing the generators of
+        the ideal, multiplied by the generator of ``other`` in terms of
+        generators of ``self``.
+
+        >>> S.module_quotient(T, relations=True)
+        (<y>, [[1]])
+
+        This means that the quotient ideal is generated by the single element
+        `y`, and that `y (x, x) = 1 (xy, xy)`, `(x, x)` and `(xy, xy)` being
+        the generators of `T` and `S`, respectively.
+        """
+        if not isinstance(other, SubModule):
+            raise TypeError('%s is not a SubModule' % other)
+        if other.container != self.container:
+            raise ValueError(
+                '%s is contained in a different free module' % other)
+        return self._module_quotient(other, **options)
+
+    def union(self, other):
+        """
+        Returns the module generated by the union of ``self`` and ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(1)
+        >>> M = F.submodule([x**2 + x]) # <x(x+1)>
+        >>> N = F.submodule([x**2 - 1]) # <(x-1)(x+1)>
+        >>> M.union(N) == F.submodule([x+1])
+        True
+        """
+        if not isinstance(other, SubModule):
+            raise TypeError('%s is not a SubModule' % other)
+        if other.container != self.container:
+            raise ValueError(
+                '%s is contained in a different free module' % other)
+        return self.__class__(self.gens + other.gens, self.container)
+
+    def is_zero(self):
+        """
+        Return True if ``self`` is a zero module.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> F.submodule([x, 1]).is_zero()
+        False
+        >>> F.submodule([0, 0]).is_zero()
+        True
+        """
+        return all(x == 0 for x in self.gens)
+
+    def submodule(self, *gens):
+        """
+        Generate a submodule.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> M = QQ.old_poly_ring(x).free_module(2).submodule([x, 1])
+        >>> M.submodule([x**2, x])
+        <[x**2, x]>
+        """
+        if not self.subset(gens):
+            raise ValueError('%s not a subset of %s' % (gens, self))
+        return self.__class__(gens, self.container)
+
+    def is_full_module(self):
+        """
+        Return True if ``self`` is the entire free module.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> F.submodule([x, 1]).is_full_module()
+        False
+        >>> F.submodule([1, 1], [1, 2]).is_full_module()
+        True
+        """
+        return all(self.contains(x) for x in self.container.basis())
+
+    def is_submodule(self, other):
+        """
+        Returns True if ``other`` is a submodule of ``self``.
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> M = F.submodule([2, x])
+        >>> N = M.submodule([2*x, x**2])
+        >>> M.is_submodule(M)
+        True
+        >>> M.is_submodule(N)
+        True
+        >>> N.is_submodule(M)
+        False
+        """
+        if isinstance(other, SubModule):
+            return self.container == other.container and \
+                all(self.contains(x) for x in other.gens)
+        if isinstance(other, (FreeModule, QuotientModule)):
+            return self.container == other and self.is_full_module()
+        return False
+
+    def syzygy_module(self, **opts):
+        r"""
+        Compute the syzygy module of the generators of ``self``.
+
+        Suppose `M` is generated by `f_1, \ldots, f_n` over the ring
+        `R`. Consider the homomorphism `\phi: R^n \to M`, given by
+        sending `(r_1, \ldots, r_n) \to r_1 f_1 + \cdots + r_n f_n`.
+        The syzygy module is defined to be the kernel of `\phi`.
+
+        Examples
+        ========
+
+        The syzygy module is zero iff the generators generate freely a free
+        submodule:
+
+        >>> from sympy.abc import x, y
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(2).submodule([1, 0], [1, 1]).syzygy_module().is_zero()
+        True
+
+        A slightly more interesting example:
+
+        >>> M = QQ.old_poly_ring(x, y).free_module(2).submodule([x, 2*x], [y, 2*y])
+        >>> S = QQ.old_poly_ring(x, y).free_module(2).submodule([y, -x])
+        >>> M.syzygy_module() == S
+        True
+        """
+        F = self.ring.free_module(len(self.gens))
+        # NOTE we filter out zero syzygies. This is for convenience of the
+        # _syzygies function and not meant to replace any real "generating set
+        # reduction" algorithm
+        return F.submodule(*[x for x in self._syzygies() if F.convert(x) != 0],
+                           **opts)
+
+    def in_terms_of_generators(self, e):
+        """
+        Express element ``e`` of ``self`` in terms of the generators.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> M = F.submodule([1, 0], [1, 1])
+        >>> M.in_terms_of_generators([x, x**2])
+        [-x**2 + x, x**2]
+        """
+        try:
+            e = self.convert(e)
+        except CoercionFailed:
+            raise ValueError('%s is not an element of %s' % (e, self))
+        return self._in_terms_of_generators(e)
+
+    def reduce_element(self, x):
+        """
+        Reduce the element ``x`` of our ring modulo the ideal ``self``.
+
+        Here "reduce" has no specific meaning, it could return a unique normal
+        form, simplify the expression a bit, or just do nothing.
+        """
+        return x
+
+    def quotient_module(self, other, **opts):
+        """
+        Return a quotient module.
+
+        This is the same as taking a submodule of a quotient of the containing
+        module.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> S1 = F.submodule([x, 1])
+        >>> S2 = F.submodule([x**2, x])
+        >>> S1.quotient_module(S2)
+        <[x, 1] + <[x**2, x]>>
+
+        Or more coincisely, using the overloaded division operator:
+
+        >>> F.submodule([x, 1]) / [(x**2, x)]
+        <[x, 1] + <[x**2, x]>>
+        """
+        if not self.is_submodule(other):
+            raise ValueError('%s not a submodule of %s' % (other, self))
+        return SubQuotientModule(self.gens,
+                self.container.quotient_module(other), **opts)
+
+    def __add__(self, oth):
+        return self.container.quotient_module(self).convert(oth)
+
+    __radd__ = __add__
+
+    def multiply_ideal(self, I):
+        """
+        Multiply ``self`` by the ideal ``I``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> I = QQ.old_poly_ring(x).ideal(x**2)
+        >>> M = QQ.old_poly_ring(x).free_module(2).submodule([1, 1])
+        >>> I*M
+        <[x**2, x**2]>
+        """
+        return self.submodule(*[x*g for [x] in I._module.gens for g in self.gens])
+
+    def inclusion_hom(self):
+        """
+        Return a homomorphism representing the inclusion map of ``self``.
+
+        That is, the natural map from ``self`` to ``self.container``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(2).submodule([x, x]).inclusion_hom()
+        Matrix([
+        [1, 0], : <[x, x]> -> QQ[x]**2
+        [0, 1]])
+        """
+        return self.container.identity_hom().restrict_domain(self)
+
+    def identity_hom(self):
+        """
+        Return the identity homomorphism on ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> QQ.old_poly_ring(x).free_module(2).submodule([x, x]).identity_hom()
+        Matrix([
+        [1, 0], : <[x, x]> -> <[x, x]>
+        [0, 1]])
+        """
+        return self.container.identity_hom().restrict_domain(
+            self).restrict_codomain(self)
+
+
+class SubQuotientModule(SubModule):
+    """
+    Submodule of a quotient module.
+
+    Equivalently, quotient module of a submodule.
+
+    Do not instantiate this, instead use the submodule or quotient_module
+    constructing methods:
+
+    >>> from sympy.abc import x
+    >>> from sympy import QQ
+    >>> F = QQ.old_poly_ring(x).free_module(2)
+    >>> S = F.submodule([1, 0], [1, x])
+    >>> Q = F/[(1, 0)]
+    >>> S/[(1, 0)] == Q.submodule([5, x])
+    True
+
+    Attributes:
+
+    - base - base module we are quotient of
+    - killed_module - submodule used to form the quotient
+    """
+    def __init__(self, gens, container, **opts):
+        SubModule.__init__(self, gens, container)
+        self.killed_module = self.container.killed_module
+        # XXX it is important for some code below that the generators of base
+        #     are in this particular order!
+        self.base = self.container.base.submodule(
+            *[x.data for x in self.gens], **opts).union(self.killed_module)
+
+    def _contains(self, elem):
+        return self.base.contains(elem.data)
+
+    def _syzygies(self):
+        # let N = self.killed_module be generated by e_1, ..., e_r
+        # let F = self.base be generated by f_1, ..., f_s and e_1, ..., e_r
+        # Then self = F/N.
+        # Let phi: R**s --> self be the evident surjection.
+        # Similarly psi: R**(s + r) --> F.
+        # We need to find generators for ker(phi). Let chi: R**s --> F be the
+        # evident lift of phi. For X in R**s, phi(X) = 0 iff chi(X) is
+        # contained in N, iff there exists Y in R**r such that
+        # psi(X, Y) = 0.
+        # Hence if alpha: R**(s + r) --> R**s is the projection map, then
+        # ker(phi) = alpha ker(psi).
+        return [X[:len(self.gens)] for X in self.base._syzygies()]
+
+    def _in_terms_of_generators(self, e):
+        return self.base._in_terms_of_generators(e.data)[:len(self.gens)]
+
+    def is_full_module(self):
+        """
+        Return True if ``self`` is the entire free module.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> F.submodule([x, 1]).is_full_module()
+        False
+        >>> F.submodule([1, 1], [1, 2]).is_full_module()
+        True
+        """
+        return self.base.is_full_module()
+
+    def quotient_hom(self):
+        """
+        Return the quotient homomorphism to self.
+
+        That is, return the natural map from ``self.base`` to ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> M = (QQ.old_poly_ring(x).free_module(2) / [(1, x)]).submodule([1, 0])
+        >>> M.quotient_hom()
+        Matrix([
+        [1, 0], : <[1, 0], [1, x]> -> <[1, 0] + <[1, x]>, [1, x] + <[1, x]>>
+        [0, 1]])
+        """
+        return self.base.identity_hom().quotient_codomain(self.killed_module)
+
+
+_subs0 = lambda x: x[0]
+_subs1 = lambda x: x[1:]
+
+
+class ModuleOrder(ProductOrder):
+    """A product monomial order with a zeroth term as module index."""
+
+    def __init__(self, o1, o2, TOP):
+        if TOP:
+            ProductOrder.__init__(self, (o2, _subs1), (o1, _subs0))
+        else:
+            ProductOrder.__init__(self, (o1, _subs0), (o2, _subs1))
+
+
+class SubModulePolyRing(SubModule):
+    """
+    Submodule of a free module over a generalized polynomial ring.
+
+    Do not instantiate this, use the constructor method of FreeModule instead:
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import QQ
+    >>> F = QQ.old_poly_ring(x, y).free_module(2)
+    >>> F.submodule([x, y], [1, 0])
+    <[x, y], [1, 0]>
+
+    Attributes:
+
+    - order - monomial order used
+    """
+
+    #self._gb - cached groebner basis
+    #self._gbe - cached groebner basis relations
+
+    def __init__(self, gens, container, order="lex", TOP=True):
+        SubModule.__init__(self, gens, container)
+        if not isinstance(container, FreeModulePolyRing):
+            raise NotImplementedError('This implementation is for submodules of '
+                             + 'FreeModulePolyRing, got %s' % container)
+        self.order = ModuleOrder(monomial_key(order), self.ring.order, TOP)
+        self._gb = None
+        self._gbe = None
+
+    def __eq__(self, other):
+        if isinstance(other, SubModulePolyRing) and self.order != other.order:
+            return False
+        return SubModule.__eq__(self, other)
+
+    def _groebner(self, extended=False):
+        """Returns a standard basis in sdm form."""
+        from sympy.polys.distributedmodules import sdm_groebner, sdm_nf_mora
+        if self._gbe is None and extended:
+            gb, gbe = sdm_groebner(
+                [self.ring._vector_to_sdm(x, self.order) for x in self.gens],
+                sdm_nf_mora, self.order, self.ring.dom, extended=True)
+            self._gb, self._gbe = tuple(gb), tuple(gbe)
+        if self._gb is None:
+            self._gb = tuple(sdm_groebner(
+                             [self.ring._vector_to_sdm(x, self.order) for x in self.gens],
+               sdm_nf_mora, self.order, self.ring.dom))
+        if extended:
+            return self._gb, self._gbe
+        else:
+            return self._gb
+
+    def _groebner_vec(self, extended=False):
+        """Returns a standard basis in element form."""
+        if not extended:
+            return [FreeModuleElement(self,
+                        tuple(self.ring._sdm_to_vector(x, self.rank)))
+                    for x in self._groebner()]
+        gb, gbe = self._groebner(extended=True)
+        return ([self.convert(self.ring._sdm_to_vector(x, self.rank))
+                 for x in gb],
+                [self.ring._sdm_to_vector(x, len(self.gens)) for x in gbe])
+
+    def _contains(self, x):
+        from sympy.polys.distributedmodules import sdm_zero, sdm_nf_mora
+        return sdm_nf_mora(self.ring._vector_to_sdm(x, self.order),
+                           self._groebner(), self.order, self.ring.dom) == \
+            sdm_zero()
+
+    def _syzygies(self):
+        """Compute syzygies. See [SCA, algorithm 2.5.4]."""
+        # NOTE if self.gens is a standard basis, this can be done more
+        #      efficiently using Schreyer's theorem
+
+        # First bullet point
+        k = len(self.gens)
+        r = self.rank
+        zero = self.ring.convert(0)
+        one = self.ring.convert(1)
+        Rkr = self.ring.free_module(r + k)
+        newgens = []
+        for j, f in enumerate(self.gens):
+            m = [0]*(r + k)
+            for i, v in enumerate(f):
+                m[i] = f[i]
+            for i in range(k):
+                m[r + i] = one if j == i else zero
+            m = FreeModuleElement(Rkr, tuple(m))
+            newgens.append(m)
+        # Note: we need *descending* order on module index, and TOP=False to
+        #       get an elimination order
+        F = Rkr.submodule(*newgens, order='ilex', TOP=False)
+
+        # Second bullet point: standard basis of F
+        G = F._groebner_vec()
+
+        # Third bullet point: G0 = G intersect the new k components
+        G0 = [x[r:] for x in G if all(y == zero for y in x[:r])]
+
+        # Fourth and fifth bullet points: we are done
+        return G0
+
+    def _in_terms_of_generators(self, e):
+        """Expression in terms of generators. See [SCA, 2.8.1]."""
+        # NOTE: if gens is a standard basis, this can be done more efficiently
+        M = self.ring.free_module(self.rank).submodule(*((e,) + self.gens))
+        S = M.syzygy_module(
+            order="ilex", TOP=False)  # We want decreasing order!
+        G = S._groebner_vec()
+        # This list cannot not be empty since e is an element
+        e = [x for x in G if self.ring.is_unit(x[0])][0]
+        return [-x/e[0] for x in e[1:]]
+
+    def reduce_element(self, x, NF=None):
+        """
+        Reduce the element ``x`` of our container modulo ``self``.
+
+        This applies the normal form ``NF`` to ``x``. If ``NF`` is passed
+        as none, the default Mora normal form is used (which is not unique!).
+        """
+        from sympy.polys.distributedmodules import sdm_nf_mora
+        if NF is None:
+            NF = sdm_nf_mora
+        return self.container.convert(self.ring._sdm_to_vector(NF(
+            self.ring._vector_to_sdm(x, self.order), self._groebner(),
+            self.order, self.ring.dom),
+            self.rank))
+
+    def _intersect(self, other, relations=False):
+        # See: [SCA, section 2.8.2]
+        fi = self.gens
+        hi = other.gens
+        r = self.rank
+        ci = [[0]*(2*r) for _ in range(r)]
+        for k in range(r):
+            ci[k][k] = 1
+            ci[k][r + k] = 1
+        di = [list(f) + [0]*r for f in fi]
+        ei = [[0]*r + list(h) for h in hi]
+        syz = self.ring.free_module(2*r).submodule(*(ci + di + ei))._syzygies()
+        nonzero = [x for x in syz if any(y != self.ring.zero for y in x[:r])]
+        res = self.container.submodule(*([-y for y in x[:r]] for x in nonzero))
+        reln1 = [x[r:r + len(fi)] for x in nonzero]
+        reln2 = [x[r + len(fi):] for x in nonzero]
+        if relations:
+            return res, reln1, reln2
+        return res
+
+    def _module_quotient(self, other, relations=False):
+        # See: [SCA, section 2.8.4]
+        if relations and len(other.gens) != 1:
+            raise NotImplementedError
+        if len(other.gens) == 0:
+            return self.ring.ideal(1)
+        elif len(other.gens) == 1:
+            # We do some trickery. Let f be the (vector!) generating ``other``
+            # and f1, .., fn be the (vectors) generating self.
+            # Consider the submodule of R^{r+1} generated by (f, 1) and
+            # {(fi, 0) | i}. Then the intersection with the last module
+            # component yields the quotient.
+            g1 = list(other.gens[0]) + [1]
+            gi = [list(x) + [0] for x in self.gens]
+            # NOTE: We *need* to use an elimination order
+            M = self.ring.free_module(self.rank + 1).submodule(*([g1] + gi),
+                                            order='ilex', TOP=False)
+            if not relations:
+                return self.ring.ideal(*[x[-1] for x in M._groebner_vec() if
+                                         all(y == self.ring.zero for y in x[:-1])])
+            else:
+                G, R = M._groebner_vec(extended=True)
+                indices = [i for i, x in enumerate(G) if
+                           all(y == self.ring.zero for y in x[:-1])]
+                return (self.ring.ideal(*[G[i][-1] for i in indices]),
+                        [[-x for x in R[i][1:]] for i in indices])
+        # For more generators, we use I : <h1, .., hn> = intersection of
+        #                                    {I : <hi> | i}
+        # TODO this can be done more efficiently
+        return reduce(lambda x, y: x.intersect(y),
+            (self._module_quotient(self.container.submodule(x)) for x in other.gens))
+
+
+class SubModuleQuotientRing(SubModule):
+    """
+    Class for submodules of free modules over quotient rings.
+
+    Do not instantiate this. Instead use the submodule methods.
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import QQ
+    >>> M = (QQ.old_poly_ring(x, y)/[x**2 - y**2]).free_module(2).submodule([x, x + y])
+    >>> M
+    <[x + <x**2 - y**2>, x + y + <x**2 - y**2>]>
+    >>> M.contains([y**2, x**2 + x*y])
+    True
+    >>> M.contains([x, y])
+    False
+
+    Attributes:
+
+    - quot - the subquotient of `R^n/IR^n` generated by lifts of our generators
+    """
+
+    def __init__(self, gens, container):
+        SubModule.__init__(self, gens, container)
+        self.quot = self.container.quot.submodule(
+            *[self.container.lift(x) for x in self.gens])
+
+    def _contains(self, elem):
+        return self.quot._contains(self.container.lift(elem))
+
+    def _syzygies(self):
+        return [tuple(self.ring.convert(y, self.quot.ring) for y in x)
+                for x in self.quot._syzygies()]
+
+    def _in_terms_of_generators(self, elem):
+        return [self.ring.convert(x, self.quot.ring) for x in
+            self.quot._in_terms_of_generators(self.container.lift(elem))]
+
+##########################################################################
+## Quotient Modules ######################################################
+##########################################################################
+
+
+class QuotientModuleElement(ModuleElement):
+    """Element of a quotient module."""
+
+    def eq(self, d1, d2):
+        """Equality comparison."""
+        return self.module.killed_module.contains(d1 - d2)
+
+    def __repr__(self):
+        return repr(self.data) + " + " + repr(self.module.killed_module)
+
+
+class QuotientModule(Module):
+    """
+    Class for quotient modules.
+
+    Do not instantiate this directly. For subquotients, see the
+    SubQuotientModule class.
+
+    Attributes:
+
+    - base - the base module we are a quotient of
+    - killed_module - the submodule used to form the quotient
+    - rank of the base
+    """
+
+    dtype = QuotientModuleElement
+
+    def __init__(self, ring, base, submodule):
+        Module.__init__(self, ring)
+        if not base.is_submodule(submodule):
+            raise ValueError('%s is not a submodule of %s' % (submodule, base))
+        self.base = base
+        self.killed_module = submodule
+        self.rank = base.rank
+
+    def __repr__(self):
+        return repr(self.base) + "/" + repr(self.killed_module)
+
+    def is_zero(self):
+        """
+        Return True if ``self`` is a zero module.
+
+        This happens if and only if the base module is the same as the
+        submodule being killed.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2)
+        >>> (F/[(1, 0)]).is_zero()
+        False
+        >>> (F/[(1, 0), (0, 1)]).is_zero()
+        True
+        """
+        return self.base == self.killed_module
+
+    def is_submodule(self, other):
+        """
+        Return True if ``other`` is a submodule of ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> Q = QQ.old_poly_ring(x).free_module(2) / [(x, x)]
+        >>> S = Q.submodule([1, 0])
+        >>> Q.is_submodule(S)
+        True
+        >>> S.is_submodule(Q)
+        False
+        """
+        if isinstance(other, QuotientModule):
+            return self.killed_module == other.killed_module and \
+                self.base.is_submodule(other.base)
+        if isinstance(other, SubQuotientModule):
+            return other.container == self
+        return False
+
+    def submodule(self, *gens, **opts):
+        """
+        Generate a submodule.
+
+        This is the same as taking a quotient of a submodule of the base
+        module.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> Q = QQ.old_poly_ring(x).free_module(2) / [(x, x)]
+        >>> Q.submodule([x, 0])
+        <[x, 0] + <[x, x]>>
+        """
+        return SubQuotientModule(gens, self, **opts)
+
+    def convert(self, elem, M=None):
+        """
+        Convert ``elem`` into the internal representation.
+
+        This method is called implicitly whenever computations involve elements
+        not in the internal representation.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> F = QQ.old_poly_ring(x).free_module(2) / [(1, 2), (1, x)]
+        >>> F.convert([1, 0])
+        [1, 0] + <[1, 2], [1, x]>
+        """
+        if isinstance(elem, QuotientModuleElement):
+            if elem.module is self:
+                return elem
+            if self.killed_module.is_submodule(elem.module.killed_module):
+                return QuotientModuleElement(self, self.base.convert(elem.data))
+            raise CoercionFailed
+        return QuotientModuleElement(self, self.base.convert(elem))
+
+    def identity_hom(self):
+        """
+        Return the identity homomorphism on ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> M = QQ.old_poly_ring(x).free_module(2) / [(1, 2), (1, x)]
+        >>> M.identity_hom()
+        Matrix([
+        [1, 0], : QQ[x]**2/<[1, 2], [1, x]> -> QQ[x]**2/<[1, 2], [1, x]>
+        [0, 1]])
+        """
+        return self.base.identity_hom().quotient_codomain(
+            self.killed_module).quotient_domain(self.killed_module)
+
+    def quotient_hom(self):
+        """
+        Return the quotient homomorphism to ``self``.
+
+        That is, return a homomorphism representing the natural map from
+        ``self.base`` to ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> from sympy import QQ
+        >>> M = QQ.old_poly_ring(x).free_module(2) / [(1, 2), (1, x)]
+        >>> M.quotient_hom()
+        Matrix([
+        [1, 0], : QQ[x]**2 -> QQ[x]**2/<[1, 2], [1, x]>
+        [0, 1]])
+        """
+        return self.base.identity_hom().quotient_codomain(
+            self.killed_module)

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/tests/test_extensions.py

@@ -0,0 +1,196 @@
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys import QQ, ZZ
+from sympy.polys.polytools import Poly
+from sympy.polys.polyerrors import NotInvertible
+from sympy.polys.agca.extensions import FiniteExtension
+from sympy.polys.domainmatrix import DomainMatrix
+
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, t
+
+
+def test_FiniteExtension():
+    # Gaussian integers
+    A = FiniteExtension(Poly(x**2 + 1, x))
+    assert A.rank == 2
+    assert str(A) == 'ZZ[x]/(x**2 + 1)'
+    i = A.generator
+    assert i.parent() is A
+
+    assert i*i == A(-1)
+    raises(TypeError, lambda: i*())
+
+    assert A.basis == (A.one, i)
+    assert A(1) == A.one
+    assert i**2 == A(-1)
+    assert i**2 != -1  # no coercion
+    assert (2 + i)*(1 - i) == 3 - i
+    assert (1 + i)**8 == A(16)
+    assert A(1).inverse() == A(1)
+    raises(NotImplementedError, lambda: A(2).inverse())
+
+    # Finite field of order 27
+    F = FiniteExtension(Poly(x**3 - x + 1, x, modulus=3))
+    assert F.rank == 3
+    a = F.generator  # also generates the cyclic group F - {0}
+    assert F.basis == (F(1), a, a**2)
+    assert a**27 == a
+    assert a**26 == F(1)
+    assert a**13 == F(-1)
+    assert a**9 == a + 1
+    assert a**3 == a - 1
+    assert a**6 == a**2 + a + 1
+    assert F(x**2 + x).inverse() == 1 - a
+    assert F(x + 2)**(-1) == F(x + 2).inverse()
+    assert a**19 * a**(-19) == F(1)
+    assert (a - 1) / (2*a**2 - 1) == a**2 + 1
+    assert (a - 1) // (2*a**2 - 1) == a**2 + 1
+    assert 2/(a**2 + 1) == a**2 - a + 1
+    assert (a**2 + 1)/2 == -a**2 - 1
+    raises(NotInvertible, lambda: F(0).inverse())
+
+    # Function field of an elliptic curve
+    K = FiniteExtension(Poly(t**2 - x**3 - x + 1, t, field=True))
+    assert K.rank == 2
+    assert str(K) == 'ZZ(x)[t]/(t**2 - x**3 - x + 1)'
+    y = K.generator
+    c = 1/(x**3 - x**2 + x - 1)
+    assert ((y + x)*(y - x)).inverse() == K(c)
+    assert (y + x)*(y - x)*c == K(1)  # explicit inverse of y + x
+
+
+def test_FiniteExtension_eq_hash():
+    # Test eq and hash
+    p1 = Poly(x**2 - 2, x, domain=ZZ)
+    p2 = Poly(x**2 - 2, x, domain=QQ)
+    K1 = FiniteExtension(p1)
+    K2 = FiniteExtension(p2)
+    assert K1 == FiniteExtension(Poly(x**2 - 2))
+    assert K2 != FiniteExtension(Poly(x**2 - 2))
+    assert len({K1, K2, FiniteExtension(p1)}) == 2
+
+
+def test_FiniteExtension_mod():
+    # Test mod
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=QQ))
+    xf = K(x)
+    assert (xf**2 - 1) % 1 == K.zero
+    assert 1 % (xf**2 - 1) == K.zero
+    assert (xf**2 - 1) / (xf - 1) == xf + 1
+    assert (xf**2 - 1) // (xf - 1) == xf + 1
+    assert (xf**2 - 1) % (xf - 1) == K.zero
+    raises(ZeroDivisionError, lambda: (xf**2 - 1) % 0)
+    raises(TypeError, lambda: xf % [])
+    raises(TypeError, lambda: [] % xf)
+
+    # Test mod over ring
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ))
+    xf = K(x)
+    assert (xf**2 - 1) % 1 == K.zero
+    raises(NotImplementedError, lambda: (xf**2 - 1) % (xf - 1))
+
+
+def test_FiniteExtension_from_sympy():
+    # Test to_sympy/from_sympy
+    K = FiniteExtension(Poly(x**3 + 1, x, domain=ZZ))
+    xf = K(x)
+    assert K.from_sympy(x) == xf
+    assert K.to_sympy(xf) == x
+
+
+def test_FiniteExtension_set_domain():
+    KZ = FiniteExtension(Poly(x**2 + 1, x, domain='ZZ'))
+    KQ = FiniteExtension(Poly(x**2 + 1, x, domain='QQ'))
+    assert KZ.set_domain(QQ) == KQ
+
+
+def test_FiniteExtension_exquo():
+    # Test exquo
+    K = FiniteExtension(Poly(x**4 + 1))
+    xf = K(x)
+    assert K.exquo(xf**2 - 1, xf - 1) == xf + 1
+
+
+def test_FiniteExtension_convert():
+    # Test from_MonogenicFiniteExtension
+    K1 = FiniteExtension(Poly(x**2 + 1))
+    K2 = QQ[x]
+    x1, x2 = K1(x), K2(x)
+    assert K1.convert(x2) == x1
+    assert K2.convert(x1) == x2
+
+    K = FiniteExtension(Poly(x**2 - 1, domain=QQ))
+    assert K.convert_from(QQ(1, 2), QQ) == K.one/2
+
+
+def test_FiniteExtension_division_ring():
+    # Test division in FiniteExtension over a ring
+    KQ = FiniteExtension(Poly(x**2 - 1, x, domain=QQ))
+    KZ = FiniteExtension(Poly(x**2 - 1, x, domain=ZZ))
+    KQt = FiniteExtension(Poly(x**2 - 1, x, domain=QQ[t]))
+    KQtf = FiniteExtension(Poly(x**2 - 1, x, domain=QQ.frac_field(t)))
+    assert KQ.is_Field is True
+    assert KZ.is_Field is False
+    assert KQt.is_Field is False
+    assert KQtf.is_Field is True
+    for K in KQ, KZ, KQt, KQtf:
+        xK = K.convert(x)
+        assert xK / K.one == xK
+        assert xK // K.one == xK
+        assert xK % K.one == K.zero
+        raises(ZeroDivisionError, lambda: xK / K.zero)
+        raises(ZeroDivisionError, lambda: xK // K.zero)
+        raises(ZeroDivisionError, lambda: xK % K.zero)
+        if K.is_Field:
+            assert xK / xK == K.one
+            assert xK // xK == K.one
+            assert xK % xK == K.zero
+        else:
+            raises(NotImplementedError, lambda: xK / xK)
+            raises(NotImplementedError, lambda: xK // xK)
+            raises(NotImplementedError, lambda: xK % xK)
+
+
+def test_FiniteExtension_Poly():
+    K = FiniteExtension(Poly(x**2 - 2))
+    p = Poly(x, y, domain=K)
+    assert p.domain == K
+    assert p.as_expr() == x
+    assert (p**2).as_expr() == 2
+
+    K = FiniteExtension(Poly(x**2 - 2, x, domain=QQ))
+    K2 = FiniteExtension(Poly(t**2 - 2, t, domain=K))
+    assert str(K2) == 'QQ[x]/(x**2 - 2)[t]/(t**2 - 2)'
+
+    eK = K2.convert(x + t)
+    assert K2.to_sympy(eK) == x + t
+    assert K2.to_sympy(eK ** 2) == 4 + 2*x*t
+    p = Poly(x + t, y, domain=K2)
+    assert p**2 == Poly(4 + 2*x*t, y, domain=K2)
+
+
+def test_FiniteExtension_sincos_jacobian():
+    # Use FiniteExtensino to compute the Jacobian of a matrix involving sin
+    # and cos of different symbols.
+    r, p, t = symbols('rho, phi, theta')
+    elements = [
+        [sin(p)*cos(t), r*cos(p)*cos(t), -r*sin(p)*sin(t)],
+        [sin(p)*sin(t), r*cos(p)*sin(t),  r*sin(p)*cos(t)],
+        [       cos(p),       -r*sin(p),                0],
+    ]
+
+    def make_extension(K):
+        K = FiniteExtension(Poly(sin(p)**2+cos(p)**2-1, sin(p), domain=K[cos(p)]))
+        K = FiniteExtension(Poly(sin(t)**2+cos(t)**2-1, sin(t), domain=K[cos(t)]))
+        return K
+
+    Ksc1 = make_extension(ZZ[r])
+    Ksc2 = make_extension(ZZ)[r]
+
+    for K in [Ksc1, Ksc2]:
+        elements_K = [[K.convert(e) for e in row] for row in elements]
+        J = DomainMatrix(elements_K, (3, 3), K)
+        det = J.charpoly()[-1] * (-K.one)**3
+        assert det == K.convert(r**2*sin(p))

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/tests/test_homomorphisms.py

@@ -0,0 +1,113 @@
+"""Tests for homomorphisms."""
+
+from sympy.core.singleton import S
+from sympy.polys.domains.rationalfield import QQ
+from sympy.abc import x, y
+from sympy.polys.agca import homomorphism
+from sympy.testing.pytest import raises
+
+
+def test_printing():
+    R = QQ.old_poly_ring(x)
+
+    assert str(homomorphism(R.free_module(1), R.free_module(1), [0])) == \
+        'Matrix([[0]]) : QQ[x]**1 -> QQ[x]**1'
+    assert str(homomorphism(R.free_module(2), R.free_module(2), [0, 0])) == \
+        'Matrix([                       \n[0, 0], : QQ[x]**2 -> QQ[x]**2\n[0, 0]])                       '
+    assert str(homomorphism(R.free_module(1), R.free_module(1) / [[x]], [0])) == \
+        'Matrix([[0]]) : QQ[x]**1 -> QQ[x]**1/<[x]>'
+    assert str(R.free_module(0).identity_hom()) == 'Matrix(0, 0, []) : QQ[x]**0 -> QQ[x]**0'
+
+def test_operations():
+    F = QQ.old_poly_ring(x).free_module(2)
+    G = QQ.old_poly_ring(x).free_module(3)
+    f = F.identity_hom()
+    g = homomorphism(F, F, [0, [1, x]])
+    h = homomorphism(F, F, [[1, 0], 0])
+    i = homomorphism(F, G, [[1, 0, 0], [0, 1, 0]])
+
+    assert f == f
+    assert f != g
+    assert f != i
+    assert (f != F.identity_hom()) is False
+    assert 2*f == f*2 == homomorphism(F, F, [[2, 0], [0, 2]])
+    assert f/2 == homomorphism(F, F, [[S.Half, 0], [0, S.Half]])
+    assert f + g == homomorphism(F, F, [[1, 0], [1, x + 1]])
+    assert f - g == homomorphism(F, F, [[1, 0], [-1, 1 - x]])
+    assert f*g == g == g*f
+    assert h*g == homomorphism(F, F, [0, [1, 0]])
+    assert g*h == homomorphism(F, F, [0, 0])
+    assert i*f == i
+    assert f([1, 2]) == [1, 2]
+    assert g([1, 2]) == [2, 2*x]
+
+    assert i.restrict_domain(F.submodule([x, x]))([x, x]) == i([x, x])
+    h1 = h.quotient_domain(F.submodule([0, 1]))
+    assert h1([1, 0]) == h([1, 0])
+    assert h1.restrict_domain(h1.domain.submodule([x, 0]))([x, 0]) == h([x, 0])
+
+    raises(TypeError, lambda: f/g)
+    raises(TypeError, lambda: f + 1)
+    raises(TypeError, lambda: f + i)
+    raises(TypeError, lambda: f - 1)
+    raises(TypeError, lambda: f*i)
+
+
+def test_creation():
+    F = QQ.old_poly_ring(x).free_module(3)
+    G = QQ.old_poly_ring(x).free_module(2)
+    SM = F.submodule([1, 1, 1])
+    Q = F / SM
+    SQ = Q.submodule([1, 0, 0])
+
+    matrix = [[1, 0], [0, 1], [-1, -1]]
+    h = homomorphism(F, G, matrix)
+    h2 = homomorphism(Q, G, matrix)
+    assert h.quotient_domain(SM) == h2
+    raises(ValueError, lambda: h.quotient_domain(F.submodule([1, 0, 0])))
+    assert h2.restrict_domain(SQ) == homomorphism(SQ, G, matrix)
+    raises(ValueError, lambda: h.restrict_domain(G))
+    raises(ValueError, lambda: h.restrict_codomain(G.submodule([1, 0])))
+    raises(ValueError, lambda: h.quotient_codomain(F))
+
+    im = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+    for M in [F, SM, Q, SQ]:
+        assert M.identity_hom() == homomorphism(M, M, im)
+    assert SM.inclusion_hom() == homomorphism(SM, F, im)
+    assert SQ.inclusion_hom() == homomorphism(SQ, Q, im)
+    assert Q.quotient_hom() == homomorphism(F, Q, im)
+    assert SQ.quotient_hom() == homomorphism(SQ.base, SQ, im)
+
+    class conv:
+        def convert(x, y=None):
+            return x
+
+    class dummy:
+        container = conv()
+
+        def submodule(*args):
+            return None
+    raises(TypeError, lambda: homomorphism(dummy(), G, matrix))
+    raises(TypeError, lambda: homomorphism(F, dummy(), matrix))
+    raises(
+        ValueError, lambda: homomorphism(QQ.old_poly_ring(x, y).free_module(3), G, matrix))
+    raises(ValueError, lambda: homomorphism(F, G, [0, 0]))
+
+
+def test_properties():
+    R = QQ.old_poly_ring(x, y)
+    F = R.free_module(2)
+    h = homomorphism(F, F, [[x, 0], [y, 0]])
+    assert h.kernel() == F.submodule([-y, x])
+    assert h.image() == F.submodule([x, 0], [y, 0])
+    assert not h.is_injective()
+    assert not h.is_surjective()
+    assert h.restrict_codomain(h.image()).is_surjective()
+    assert h.restrict_domain(F.submodule([1, 0])).is_injective()
+    assert h.quotient_domain(
+        h.kernel()).restrict_codomain(h.image()).is_isomorphism()
+
+    R2 = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
+    F = R2.free_module(2)
+    h = homomorphism(F, F, [[x, 0], [y, y + 1]])
+    assert h.is_isomorphism()

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/tests/test_ideals.py

@@ -0,0 +1,131 @@
+"""Test ideals.py code."""
+
+from sympy.polys import QQ, ilex
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+
+
+def test_ideal_operations():
+    R = QQ.old_poly_ring(x, y)
+    I = R.ideal(x)
+    J = R.ideal(y)
+    S = R.ideal(x*y)
+    T = R.ideal(x, y)
+
+    assert not (I == J)
+    assert I == I
+
+    assert I.union(J) == T
+    assert I + J == T
+    assert I + T == T
+
+    assert not I.subset(T)
+    assert T.subset(I)
+
+    assert I.product(J) == S
+    assert I*J == S
+    assert x*J == S
+    assert I*y == S
+    assert R.convert(x)*J == S
+    assert I*R.convert(y) == S
+
+    assert not I.is_zero()
+    assert not J.is_whole_ring()
+
+    assert R.ideal(x**2 + 1, x).is_whole_ring()
+    assert R.ideal() == R.ideal(0)
+    assert R.ideal().is_zero()
+
+    assert T.contains(x*y)
+    assert T.subset([x, y])
+
+    assert T.in_terms_of_generators(x) == [R(1), R(0)]
+
+    assert T**0 == R.ideal(1)
+    assert T**1 == T
+    assert T**2 == R.ideal(x**2, y**2, x*y)
+    assert I**5 == R.ideal(x**5)
+
+
+def test_exceptions():
+    I = QQ.old_poly_ring(x).ideal(x)
+    J = QQ.old_poly_ring(y).ideal(1)
+    raises(ValueError, lambda: I.union(x))
+    raises(ValueError, lambda: I + J)
+    raises(ValueError, lambda: I * J)
+    raises(ValueError, lambda: I.union(J))
+    assert (I == J) is False
+    assert I != J
+
+
+def test_nontriv_global():
+    R = QQ.old_poly_ring(x, y, z)
+
+    def contains(I, f):
+        return R.ideal(*I).contains(f)
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**3)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4 + y**3 + 2*z*y*x)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y*z)
+    assert contains([x, 1 + x + y, 5 - 7*y], 1)
+    assert contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**3)
+    assert not contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**2 + y**2)
+
+    # compare local order
+    assert not contains([x*(1 + x + y), y*(1 + z)], x)
+    assert not contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_nontriv_local():
+    R = QQ.old_poly_ring(x, y, z, order=ilex)
+
+    def contains(I, f):
+        return R.ideal(*I).contains(f)
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x*(1 + x + y), y*(1 + z)], x)
+    assert contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_intersection():
+    R = QQ.old_poly_ring(x, y, z)
+    # SCA, example 1.8.11
+    assert R.ideal(x, y).intersect(R.ideal(y**2, z)) == R.ideal(y**2, y*z, x*z)
+
+    assert R.ideal(x, y).intersect(R.ideal()).is_zero()
+
+    R = QQ.old_poly_ring(x, y, z, order="ilex")
+    assert R.ideal(x, y).intersect(R.ideal(y**2 + y**2*z, z + z*x**3*y)) == \
+        R.ideal(y**2, y*z, x*z)
+
+
+def test_quotient():
+    # SCA, example 1.8.13
+    R = QQ.old_poly_ring(x, y, z)
+    assert R.ideal(x, y).quotient(R.ideal(y**2, z)) == R.ideal(x, y)
+
+
+def test_reduction():
+    from sympy.polys.distributedmodules import sdm_nf_buchberger_reduced
+    R = QQ.old_poly_ring(x, y)
+    I = R.ideal(x**5, y)
+    e = R.convert(x**3 + y**2)
+    assert I.reduce_element(e) == e
+    assert I.reduce_element(e, NF=sdm_nf_buchberger_reduced) == R.convert(x**3)

env-llmeval/lib/python3.10/site-packages/sympy/polys/agca/tests/test_modules.py

@@ -0,0 +1,408 @@
+"""Test modules.py code."""
+
+from sympy.polys.agca.modules import FreeModule, ModuleOrder, FreeModulePolyRing
+from sympy.polys import CoercionFailed, QQ, lex, grlex, ilex, ZZ
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+from sympy.core.numbers import Rational
+
+
+def test_FreeModuleElement():
+    M = QQ.old_poly_ring(x).free_module(3)
+    e = M.convert([1, x, x**2])
+    f = [QQ.old_poly_ring(x).convert(1), QQ.old_poly_ring(x).convert(x), QQ.old_poly_ring(x).convert(x**2)]
+    assert list(e) == f
+    assert f[0] == e[0]
+    assert f[1] == e[1]
+    assert f[2] == e[2]
+    raises(IndexError, lambda: e[3])
+
+    g = M.convert([x, 0, 0])
+    assert e + g == M.convert([x + 1, x, x**2])
+    assert f + g == M.convert([x + 1, x, x**2])
+    assert -e == M.convert([-1, -x, -x**2])
+    assert e - g == M.convert([1 - x, x, x**2])
+    assert e != g
+
+    assert M.convert([x, x, x]) / QQ.old_poly_ring(x).convert(x) == [1, 1, 1]
+    R = QQ.old_poly_ring(x, order="ilex")
+    assert R.free_module(1).convert([x]) / R.convert(x) == [1]
+
+
+def test_FreeModule():
+    M1 = FreeModule(QQ.old_poly_ring(x), 2)
+    assert M1 == FreeModule(QQ.old_poly_ring(x), 2)
+    assert M1 != FreeModule(QQ.old_poly_ring(y), 2)
+    assert M1 != FreeModule(QQ.old_poly_ring(x), 3)
+    M2 = FreeModule(QQ.old_poly_ring(x, order="ilex"), 2)
+
+    assert [x, 1] in M1
+    assert [x] not in M1
+    assert [2, y] not in M1
+    assert [1/(x + 1), 2] not in M1
+
+    e = M1.convert([x, x**2 + 1])
+    X = QQ.old_poly_ring(x).convert(x)
+    assert e == [X, X**2 + 1]
+    assert e == [x, x**2 + 1]
+    assert 2*e == [2*x, 2*x**2 + 2]
+    assert e*2 == [2*x, 2*x**2 + 2]
+    assert e/2 == [x/2, (x**2 + 1)/2]
+    assert x*e == [x**2, x**3 + x]
+    assert e*x == [x**2, x**3 + x]
+    assert X*e == [x**2, x**3 + x]
+    assert e*X == [x**2, x**3 + x]
+
+    assert [x, 1] in M2
+    assert [x] not in M2
+    assert [2, y] not in M2
+    assert [1/(x + 1), 2] in M2
+
+    e = M2.convert([x, x**2 + 1])
+    X = QQ.old_poly_ring(x, order="ilex").convert(x)
+    assert e == [X, X**2 + 1]
+    assert e == [x, x**2 + 1]
+    assert 2*e == [2*x, 2*x**2 + 2]
+    assert e*2 == [2*x, 2*x**2 + 2]
+    assert e/2 == [x/2, (x**2 + 1)/2]
+    assert x*e == [x**2, x**3 + x]
+    assert e*x == [x**2, x**3 + x]
+    assert e/(1 + x) == [x/(1 + x), (x**2 + 1)/(1 + x)]
+    assert X*e == [x**2, x**3 + x]
+    assert e*X == [x**2, x**3 + x]
+
+    M3 = FreeModule(QQ.old_poly_ring(x, y), 2)
+    assert M3.convert(e) == M3.convert([x, x**2 + 1])
+
+    assert not M3.is_submodule(0)
+    assert not M3.is_zero()
+
+    raises(NotImplementedError, lambda: ZZ.old_poly_ring(x).free_module(2))
+    raises(NotImplementedError, lambda: FreeModulePolyRing(ZZ, 2))
+    raises(CoercionFailed, lambda: M1.convert(QQ.old_poly_ring(x).free_module(3)
+           .convert([1, 2, 3])))
+    raises(CoercionFailed, lambda: M3.convert(1))
+
+
+def test_ModuleOrder():
+    o1 = ModuleOrder(lex, grlex, False)
+    o2 = ModuleOrder(ilex, lex, False)
+
+    assert o1 == ModuleOrder(lex, grlex, False)
+    assert (o1 != ModuleOrder(lex, grlex, False)) is False
+    assert o1 != o2
+
+    assert o1((1, 2, 3)) == (1, (5, (2, 3)))
+    assert o2((1, 2, 3)) == (-1, (2, 3))
+
+
+def test_SubModulePolyRing_global():
+    R = QQ.old_poly_ring(x, y)
+    F = R.free_module(3)
+    Fd = F.submodule([1, 0, 0], [1, 2, 0], [1, 2, 3])
+    M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
+
+    assert F == Fd
+    assert Fd == F
+    assert F != M
+    assert M != F
+    assert Fd != M
+    assert M != Fd
+    assert Fd == F.submodule(*F.basis())
+
+    assert Fd.is_full_module()
+    assert not M.is_full_module()
+    assert not Fd.is_zero()
+    assert not M.is_zero()
+    assert Fd.submodule().is_zero()
+
+    assert M.contains([x**2 + y**2 + x, 1 + y, 1])
+    assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
+    assert M.contains([y**2, 1 - x*y, -x])
+
+    assert not F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
+    assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
+    assert not M.is_submodule(0)
+
+    m = F.convert([x**2 + y**2, 1, 0])
+    n = M.convert(m)
+    assert m.module is F
+    assert n.module is M
+
+    raises(ValueError, lambda: M.submodule([1, 0, 0]))
+    raises(TypeError, lambda: M.union(1))
+    raises(ValueError, lambda: M.union(R.free_module(1).submodule([x])))
+
+    assert F.submodule([x, x, x]) != F.submodule([x, x, x], order="ilex")
+
+
+def test_SubModulePolyRing_local():
+    R = QQ.old_poly_ring(x, y, order=ilex)
+    F = R.free_module(3)
+    Fd = F.submodule([1 + x, 0, 0], [1 + y, 2 + 2*y, 0], [1, 2, 3])
+    M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
+
+    assert F == Fd
+    assert Fd == F
+    assert F != M
+    assert M != F
+    assert Fd != M
+    assert M != Fd
+    assert Fd == F.submodule(*F.basis())
+
+    assert Fd.is_full_module()
+    assert not M.is_full_module()
+    assert not Fd.is_zero()
+    assert not M.is_zero()
+    assert Fd.submodule().is_zero()
+
+    assert M.contains([x**2 + y**2 + x, 1 + y, 1])
+    assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
+    assert M.contains([y**2, 1 - x*y, -x])
+
+    assert F.submodule([1 + x, 0, 0]) == F.submodule([1, 0, 0])
+    assert F.submodule(
+        [1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1 + x*y])) == F
+
+    raises(ValueError, lambda: M.submodule([1, 0, 0]))
+
+
+def test_SubModulePolyRing_nontriv_global():
+    R = QQ.old_poly_ring(x, y, z)
+    F = R.free_module(1)
+
+    def contains(I, f):
+        return F.submodule(*[[g] for g in I]).contains([f])
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**3)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y**2)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4 + y**3 + 2*z*y*x)
+    assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y*z)
+    assert contains([x, 1 + x + y, 5 - 7*y], 1)
+    assert contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**3)
+    assert not contains(
+        [x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
+        x**2 + y**2)
+
+    # compare local order
+    assert not contains([x*(1 + x + y), y*(1 + z)], x)
+    assert not contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_SubModulePolyRing_nontriv_local():
+    R = QQ.old_poly_ring(x, y, z, order=ilex)
+    F = R.free_module(1)
+
+    def contains(I, f):
+        return F.submodule(*[[g] for g in I]).contains([f])
+
+    assert contains([x, y], x)
+    assert contains([x, y], x + y)
+    assert not contains([x, y], 1)
+    assert not contains([x, y], z)
+    assert contains([x**2 + y, x**2 + x], x - y)
+    assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
+    assert contains([x*(1 + x + y), y*(1 + z)], x)
+    assert contains([x*(1 + x + y), y*(1 + z)], x + y)
+
+
+def test_syzygy():
+    R = QQ.old_poly_ring(x, y, z)
+    M = R.free_module(1).submodule([x*y], [y*z], [x*z])
+    S = R.free_module(3).submodule([0, x, -y], [z, -x, 0])
+    assert M.syzygy_module() == S
+
+    M2 = M / ([x*y*z],)
+    S2 = R.free_module(3).submodule([z, 0, 0], [0, x, 0], [0, 0, y])
+    assert M2.syzygy_module() == S2
+
+    F = R.free_module(3)
+    assert F.submodule(*F.basis()).syzygy_module() == F.submodule()
+
+    R2 = QQ.old_poly_ring(x, y, z) / [x*y*z]
+    M3 = R2.free_module(1).submodule([x*y], [y*z], [x*z])
+    S3 = R2.free_module(3).submodule([z, 0, 0], [0, x, 0], [0, 0, y])
+    assert M3.syzygy_module() == S3
+
+
+def test_in_terms_of_generators():
+    R = QQ.old_poly_ring(x, order="ilex")
+    M = R.free_module(2).submodule([2*x, 0], [1, 2])
+    assert M.in_terms_of_generators(
+        [x, x]) == [R.convert(Rational(1, 4)), R.convert(x/2)]
+    raises(ValueError, lambda: M.in_terms_of_generators([1, 0]))
+
+    M = R.free_module(2) / ([x, 0], [1, 1])
+    SM = M.submodule([1, x])
+    assert SM.in_terms_of_generators([2, 0]) == [R.convert(-2/(x - 1))]
+
+    R = QQ.old_poly_ring(x, y) / [x**2 - y**2]
+    M = R.free_module(2)
+    SM = M.submodule([x, 0], [0, y])
+    assert SM.in_terms_of_generators(
+        [x**2, x**2]) == [R.convert(x), R.convert(y)]
+
+
+def test_QuotientModuleElement():
+    R = QQ.old_poly_ring(x)
+    F = R.free_module(3)
+    N = F.submodule([1, x, x**2])
+    M = F/N
+    e = M.convert([x**2, 2, 0])
+
+    assert M.convert([x + 1, x**2 + x, x**3 + x**2]) == 0
+    assert e == [x**2, 2, 0] + N == F.convert([x**2, 2, 0]) + N == \
+        M.convert(F.convert([x**2, 2, 0]))
+
+    assert M.convert([x**2 + 1, 2*x + 2, x**2]) == e + [0, x, 0] == \
+        e + M.convert([0, x, 0]) == e + F.convert([0, x, 0])
+    assert M.convert([x**2 + 1, 2, x**2]) == e - [0, x, 0] == \
+        e - M.convert([0, x, 0]) == e - F.convert([0, x, 0])
+    assert M.convert([0, 2, 0]) == M.convert([x**2, 4, 0]) - e == \
+        [x**2, 4, 0] - e == F.convert([x**2, 4, 0]) - e
+    assert M.convert([x**3 + x**2, 2*x + 2, 0]) == (1 + x)*e == \
+        R.convert(1 + x)*e == e*(1 + x) == e*R.convert(1 + x)
+    assert -e == [-x**2, -2, 0]
+
+    f = [x, x, 0] + N
+    assert M.convert([1, 1, 0]) == f / x == f / R.convert(x)
+
+    M2 = F/[(2, 2*x, 2*x**2), (0, 0, 1)]
+    G = R.free_module(2)
+    M3 = G/[[1, x]]
+    M4 = F.submodule([1, x, x**2], [1, 0, 0]) / N
+    raises(CoercionFailed, lambda: M.convert(G.convert([1, x])))
+    raises(CoercionFailed, lambda: M.convert(M3.convert([1, x])))
+    raises(CoercionFailed, lambda: M.convert(M2.convert([1, x, x])))
+    assert M2.convert(M.convert([2, x, x**2])) == [2, x, 0]
+    assert M.convert(M4.convert([2, 0, 0])) == [2, 0, 0]
+
+
+def test_QuotientModule():
+    R = QQ.old_poly_ring(x)
+    F = R.free_module(3)
+    N = F.submodule([1, x, x**2])
+    M = F/N
+
+    assert M != F
+    assert M != N
+    assert M == F / [(1, x, x**2)]
+    assert not M.is_zero()
+    assert (F / F.basis()).is_zero()
+
+    SQ = F.submodule([1, x, x**2], [2, 0, 0]) / N
+    assert SQ == M.submodule([2, x, x**2])
+    assert SQ != M.submodule([2, 1, 0])
+    assert SQ != M
+    assert M.is_submodule(SQ)
+    assert not SQ.is_full_module()
+
+    raises(ValueError, lambda: N/F)
+    raises(ValueError, lambda: F.submodule([2, 0, 0]) / N)
+    raises(ValueError, lambda: R.free_module(2)/F)
+    raises(CoercionFailed, lambda: F.convert(M.convert([1, x, x**2])))
+
+    M1 = F / [[1, 1, 1]]
+    M2 = M1.submodule([1, 0, 0], [0, 1, 0])
+    assert M1 == M2
+
+
+def test_ModulesQuotientRing():
+    R = QQ.old_poly_ring(x, y, order=(("lex", x), ("ilex", y))) / [x**2 + 1]
+    M1 = R.free_module(2)
+    assert M1 == R.free_module(2)
+    assert M1 != QQ.old_poly_ring(x).free_module(2)
+    assert M1 != R.free_module(3)
+
+    assert [x, 1] in M1
+    assert [x] not in M1
+    assert [1/(R.convert(x) + 1), 2] in M1
+    assert [1, 2/(1 + y)] in M1
+    assert [1, 2/y] not in M1
+
+    assert M1.convert([x**2, y]) == [-1, y]
+
+    F = R.free_module(3)
+    Fd = F.submodule([x**2, 0, 0], [1, 2, 0], [1, 2, 3])
+    M = F.submodule([x**2 + y**2, 1, 0], [x, y, 1])
+
+    assert F == Fd
+    assert Fd == F
+    assert F != M
+    assert M != F
+    assert Fd != M
+    assert M != Fd
+    assert Fd == F.submodule(*F.basis())
+
+    assert Fd.is_full_module()
+    assert not M.is_full_module()
+    assert not Fd.is_zero()
+    assert not M.is_zero()
+    assert Fd.submodule().is_zero()
+
+    assert M.contains([x**2 + y**2 + x, -x**2 + y, 1])
+    assert not M.contains([x**2 + y**2 + x, 1 + y, 2])
+    assert M.contains([y**2, 1 - x*y, -x])
+
+    assert F.submodule([x, 0, 0]) == F.submodule([1, 0, 0])
+    assert not F.submodule([y, 0, 0]) == F.submodule([1, 0, 0])
+    assert F.submodule([1, 0, 0], [0, 1, 0]).union(F.submodule([0, 0, 1])) == F
+    assert not M.is_submodule(0)
+
+
+def test_module_mul():
+    R = QQ.old_poly_ring(x)
+    M = R.free_module(2)
+    S1 = M.submodule([x, 0], [0, x])
+    S2 = M.submodule([x**2, 0], [0, x**2])
+    I = R.ideal(x)
+
+    assert I*M == M*I == S1 == x*M == M*x
+    assert I*S1 == S2 == x*S1
+
+
+def test_intersection():
+    # SCA, example 2.8.5
+    F = QQ.old_poly_ring(x, y).free_module(2)
+    M1 = F.submodule([x, y], [y, 1])
+    M2 = F.submodule([0, y - 1], [x, 1], [y, x])
+    I = F.submodule([x, y], [y**2 - y, y - 1], [x*y + y, x + 1])
+    I1, rel1, rel2 = M1.intersect(M2, relations=True)
+    assert I1 == M2.intersect(M1) == I
+    for i, g in enumerate(I1.gens):
+        assert g == sum(c*x for c, x in zip(rel1[i], M1.gens)) \
+                 == sum(d*y for d, y in zip(rel2[i], M2.gens))
+
+    assert F.submodule([x, y]).intersect(F.submodule([y, x])).is_zero()
+
+
+def test_quotient():
+    # SCA, example 2.8.6
+    R = QQ.old_poly_ring(x, y, z)
+    F = R.free_module(2)
+    assert F.submodule([x*y, x*z], [y*z, x*y]).module_quotient(
+        F.submodule([y, z], [z, y])) == QQ.old_poly_ring(x, y, z).ideal(x**2*y**2 - x*y*z**2)
+    assert F.submodule([x, y]).module_quotient(F.submodule()).is_whole_ring()
+
+    M = F.submodule([x**2, x**2], [y**2, y**2])
+    N = F.submodule([x + y, x + y])
+    q, rel = M.module_quotient(N, relations=True)
+    assert q == R.ideal(y**2, x - y)
+    for i, g in enumerate(q.gens):
+        assert g*N.gens[0] == sum(c*x for c, x in zip(rel[i], M.gens))
+
+
+def test_groebner_extendend():
+    M = QQ.old_poly_ring(x, y, z).free_module(3).submodule([x + 1, y, 1], [x*y, z, z**2])
+    G, R = M._groebner_vec(extended=True)
+    for i, g in enumerate(G):
+        assert g == sum(c*gen for c, gen in zip(R[i], M.gens))

env-llmeval/lib/python3.10/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',
+]

env-llmeval/lib/python3.10/site-packages/sympy/polys/matrices/_typing.py

@@ -0,0 +1,12 @@
+from typing import TypeVar, Protocol
+
+
+T = TypeVar('T')
+
+
+class RingElement(Protocol):
+    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: ...

env-llmeval/lib/python3.10/site-packages/sympy/polys/matrices/ddm.py

@@ -0,0 +1,496 @@
+"""
+
+Module for the DDM class.
+
+The DDM class is an internal representation used by DomainMatrix. The letters
+DDM stand for Dense Domain Matrix. A DDM instance represents a matrix using
+elements from a polynomial Domain (e.g. ZZ, QQ, ...) in a dense-matrix
+representation.
+
+Basic usage:
+
+    >>> from sympy import ZZ, QQ
+    >>> from sympy.polys.matrices.ddm import DDM
+    >>> A = DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
+    >>> A.shape
+    (2, 2)
+    >>> A
+    [[0, 1], [-1, 0]]
+    >>> type(A)
+    <class 'sympy.polys.matrices.ddm.DDM'>
+    >>> A @ A
+    [[-1, 0], [0, -1]]
+
+The ddm_* functions are designed to operate on DDM as well as on an ordinary
+list of lists:
+
+    >>> from sympy.polys.matrices.dense import ddm_idet
+    >>> ddm_idet(A, QQ)
+    1
+    >>> ddm_idet([[0, 1], [-1, 0]], QQ)
+    1
+    >>> A
+    [[-1, 0], [0, -1]]
+
+Note that ddm_idet modifies the input matrix in-place. It is recommended to
+use the DDM.det method as a friendlier interface to this instead which takes
+care of copying the matrix:
+
+    >>> B = DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
+    >>> B.det()
+    1
+
+Normally DDM would not be used directly and is just part of the internal
+representation of DomainMatrix which adds further functionality including e.g.
+unifying domains.
+
+The dense format used by DDM is a list of lists of elements e.g. the 2x2
+identity matrix is like [[1, 0], [0, 1]]. The DDM class itself is a subclass
+of list and its list items are plain lists. Elements are accessed as e.g.
+ddm[i][j] where ddm[i] gives the ith row and ddm[i][j] gets the element in the
+jth column of that row. Subclassing list makes e.g. iteration and indexing
+very efficient. We do not override __getitem__ because it would lose that
+benefit.
+
+The core routines are implemented by the ddm_* functions defined in dense.py.
+Those functions are intended to be able to operate on a raw list-of-lists
+representation of matrices with most functions operating in-place. The DDM
+class takes care of copying etc and also stores a Domain object associated
+with its elements. This makes it possible to implement things like A + B with
+domain checking and also shape checking so that the list of lists
+representation is friendlier.
+
+"""
+from itertools import chain
+
+from .exceptions import DMBadInputError, DMShapeError, DMDomainError
+
+from .dense import (
+        ddm_transpose,
+        ddm_iadd,
+        ddm_isub,
+        ddm_ineg,
+        ddm_imul,
+        ddm_irmul,
+        ddm_imatmul,
+        ddm_irref,
+        ddm_idet,
+        ddm_iinv,
+        ddm_ilu_split,
+        ddm_ilu_solve,
+        ddm_berk,
+        )
+
+from sympy.polys.domains import QQ
+from .lll import ddm_lll, ddm_lll_transform
+
+
+class DDM(list):
+    """Dense matrix based on polys domain elements
+
+    This is a list subclass and is a wrapper for a list of lists that supports
+    basic matrix arithmetic +, -, *, **.
+    """
+
+    fmt = 'dense'
+
+    def __init__(self, rowslist, shape, domain):
+        super().__init__(rowslist)
+        self.shape = self.rows, self.cols = m, n = shape
+        self.domain = domain
+
+        if not (len(self) == m and all(len(row) == n for row in self)):
+            raise DMBadInputError("Inconsistent row-list/shape")
+
+    def getitem(self, i, j):
+        return self[i][j]
+
+    def setitem(self, i, j, value):
+        self[i][j] = value
+
+    def extract_slice(self, slice1, slice2):
+        ddm = [row[slice2] for row in self[slice1]]
+        rows = len(ddm)
+        cols = len(ddm[0]) if ddm else len(range(self.shape[1])[slice2])
+        return DDM(ddm, (rows, cols), self.domain)
+
+    def extract(self, rows, cols):
+        ddm = []
+        for i in rows:
+            rowi = self[i]
+            ddm.append([rowi[j] for j in cols])
+        return DDM(ddm, (len(rows), len(cols)), self.domain)
+
+    def to_list(self):
+        return list(self)
+
+    def to_list_flat(self):
+        flat = []
+        for row in self:
+            flat.extend(row)
+        return flat
+
+    def flatiter(self):
+        return chain.from_iterable(self)
+
+    def flat(self):
+        items = []
+        for row in self:
+            items.extend(row)
+        return items
+
+    def to_dok(self):
+        return {(i, j): e for i, row in enumerate(self) for j, e in enumerate(row)}
+
+    def to_ddm(self):
+        return self
+
+    def to_sdm(self):
+        return SDM.from_list(self, self.shape, self.domain)
+
+    def convert_to(self, K):
+        Kold = self.domain
+        if K == Kold:
+            return self.copy()
+        rows = ([K.convert_from(e, Kold) for e in row] for row in self)
+        return DDM(rows, self.shape, K)
+
+    def __str__(self):
+        rowsstr = ['[%s]' % ', '.join(map(str, row)) for row in self]
+        return '[%s]' % ', '.join(rowsstr)
+
+    def __repr__(self):
+        cls = type(self).__name__
+        rows = list.__repr__(self)
+        return '%s(%s, %s, %s)' % (cls, rows, self.shape, self.domain)
+
+    def __eq__(self, other):
+        if not isinstance(other, DDM):
+            return False
+        return (super().__eq__(other) and self.domain == other.domain)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        z = domain.zero
+        m, n = shape
+        rowslist = ([z] * n for _ in range(m))
+        return DDM(rowslist, shape, domain)
+
+    @classmethod
+    def ones(cls, shape, domain):
+        one = domain.one
+        m, n = shape
+        rowlist = ([one] * n for _ in range(m))
+        return DDM(rowlist, shape, domain)
+
+    @classmethod
+    def eye(cls, size, domain):
+        one = domain.one
+        ddm = cls.zeros((size, size), domain)
+        for i in range(size):
+            ddm[i][i] = one
+        return ddm
+
+    def copy(self):
+        copyrows = (row[:] for row in self)
+        return DDM(copyrows, self.shape, self.domain)
+
+    def transpose(self):
+        rows, cols = self.shape
+        if rows:
+            ddmT = ddm_transpose(self)
+        else:
+            ddmT = [[]] * cols
+        return DDM(ddmT, (cols, rows), self.domain)
+
+    def __add__(a, b):
+        if not isinstance(b, DDM):
+            return NotImplemented
+        return a.add(b)
+
+    def __sub__(a, b):
+        if not isinstance(b, DDM):
+            return NotImplemented
+        return a.sub(b)
+
+    def __neg__(a):
+        return a.neg()
+
+    def __mul__(a, b):
+        if b in a.domain:
+            return a.mul(b)
+        else:
+            return NotImplemented
+
+    def __rmul__(a, b):
+        if b in a.domain:
+            return a.mul(b)
+        else:
+            return NotImplemented
+
+    def __matmul__(a, b):
+        if isinstance(b, DDM):
+            return a.matmul(b)
+        else:
+            return NotImplemented
+
+    @classmethod
+    def _check(cls, a, op, b, ashape, bshape):
+        if a.domain != b.domain:
+            msg = "Domain mismatch: %s %s %s" % (a.domain, op, b.domain)
+            raise DMDomainError(msg)
+        if ashape != bshape:
+            msg = "Shape mismatch: %s %s %s" % (a.shape, op, b.shape)
+            raise DMShapeError(msg)
+
+    def add(a, b):
+        """a + b"""
+        a._check(a, '+', b, a.shape, b.shape)
+        c = a.copy()
+        ddm_iadd(c, b)
+        return c
+
+    def sub(a, b):
+        """a - b"""
+        a._check(a, '-', b, a.shape, b.shape)
+        c = a.copy()
+        ddm_isub(c, b)
+        return c
+
+    def neg(a):
+        """-a"""
+        b = a.copy()
+        ddm_ineg(b)
+        return b
+
+    def mul(a, b):
+        c = a.copy()
+        ddm_imul(c, b)
+        return c
+
+    def rmul(a, b):
+        c = a.copy()
+        ddm_irmul(c, b)
+        return c
+
+    def matmul(a, b):
+        """a @ b (matrix product)"""
+        m, o = a.shape
+        o2, n = b.shape
+        a._check(a, '*', b, o, o2)
+        c = a.zeros((m, n), a.domain)
+        ddm_imatmul(c, a, b)
+        return c
+
+    def mul_elementwise(a, b):
+        assert a.shape == b.shape
+        assert a.domain == b.domain
+        c = [[aij * bij for aij, bij in zip(ai, bi)] for ai, bi in zip(a, b)]
+        return DDM(c, a.shape, a.domain)
+
+    def hstack(A, *B):
+        """Horizontally stacks :py:class:`~.DDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import DDM
+
+        >>> A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DDM([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.hstack(B)
+        [[1, 2, 5, 6], [3, 4, 7, 8]]
+
+        >>> C = DDM([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        [[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]]
+        """
+        Anew = list(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkrows == rows
+            assert Bk.domain == domain
+
+            cols += Bkcols
+
+            for i, Bki in enumerate(Bk):
+                Anew[i].extend(Bki)
+
+        return DDM(Anew, (rows, cols), A.domain)
+
+    def vstack(A, *B):
+        """Vertically stacks :py:class:`~.DDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import DDM
+
+        >>> A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DDM([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.vstack(B)
+        [[1, 2], [3, 4], [5, 6], [7, 8]]
+
+        >>> C = DDM([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]
+        """
+        Anew = list(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkcols == cols
+            assert Bk.domain == domain
+
+            rows += Bkrows
+
+            Anew.extend(Bk.copy())
+
+        return DDM(Anew, (rows, cols), A.domain)
+
+    def applyfunc(self, func, domain):
+        elements = (list(map(func, row)) for row in self)
+        return DDM(elements, self.shape, domain)
+
+    def scc(a):
+        """Strongly connected components of a square matrix *a*.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import DDM
+        >>> A = DDM([[ZZ(1), ZZ(0)], [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+        >>> A.scc()
+        [[0], [1]]
+
+        See also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.scc
+
+        """
+        return a.to_sdm().scc()
+
+    def rref(a):
+        """Reduced-row echelon form of a and list of pivots"""
+        b = a.copy()
+        K = a.domain
+        partial_pivot = K.is_RealField or K.is_ComplexField
+        pivots = ddm_irref(b, _partial_pivot=partial_pivot)
+        return b, pivots
+
+    def nullspace(a):
+        rref, pivots = a.rref()
+        rows, cols = a.shape
+        domain = a.domain
+
+        basis = []
+        nonpivots = []
+        for i in range(cols):
+            if i in pivots:
+                continue
+            nonpivots.append(i)
+            vec = [domain.one if i == j else domain.zero for j in range(cols)]
+            for ii, jj in enumerate(pivots):
+                vec[jj] -= rref[ii][i]
+            basis.append(vec)
+
+        return DDM(basis, (len(basis), cols), domain), nonpivots
+
+    def particular(a):
+        return a.to_sdm().particular().to_ddm()
+
+    def det(a):
+        """Determinant of a"""
+        m, n = a.shape
+        if m != n:
+            raise DMShapeError("Determinant of non-square matrix")
+        b = a.copy()
+        K = b.domain
+        deta = ddm_idet(b, K)
+        return deta
+
+    def inv(a):
+        """Inverse of a"""
+        m, n = a.shape
+        if m != n:
+            raise DMShapeError("Determinant of non-square matrix")
+        ainv = a.copy()
+        K = a.domain
+        ddm_iinv(ainv, a, K)
+        return ainv
+
+    def lu(a):
+        """L, U decomposition of a"""
+        m, n = a.shape
+        K = a.domain
+
+        U = a.copy()
+        L = a.eye(m, K)
+        swaps = ddm_ilu_split(L, U, K)
+
+        return L, U, swaps
+
+    def lu_solve(a, b):
+        """x where a*x = b"""
+        m, n = a.shape
+        m2, o = b.shape
+        a._check(a, 'lu_solve', b, m, m2)
+
+        L, U, swaps = a.lu()
+        x = a.zeros((n, o), a.domain)
+        ddm_ilu_solve(x, L, U, swaps, b)
+        return x
+
+    def charpoly(a):
+        """Coefficients of characteristic polynomial of a"""
+        K = a.domain
+        m, n = a.shape
+        if m != n:
+            raise DMShapeError("Charpoly of non-square matrix")
+        vec = ddm_berk(a, K)
+        coeffs = [vec[i][0] for i in range(n+1)]
+        return coeffs
+
+    def is_zero_matrix(self):
+        """
+        Says whether this matrix has all zero entries.
+        """
+        zero = self.domain.zero
+        return all(Mij == zero for Mij in self.flatiter())
+
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        zero = self.domain.zero
+        return all(Mij == zero for i, Mi in enumerate(self) for Mij in Mi[:i])
+
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        zero = self.domain.zero
+        return all(Mij == zero for i, Mi in enumerate(self) for Mij in Mi[i+1:])
+
+    def lll(A, delta=QQ(3, 4)):
+        return ddm_lll(A, delta=delta)
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        return ddm_lll_transform(A, delta=delta)
+
+
+from .sdm import SDM

env-llmeval/lib/python3.10/site-packages/sympy/polys/matrices/dense.py

@@ -0,0 +1,348 @@
+"""
+
+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,
+    DMNonInvertibleMatrixError,
+    DMNonSquareMatrixError,
+)
+from typing import Sequence, TypeVar
+from sympy.polys.matrices._typing import RingElement
+
+
+T = TypeVar('T')
+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:
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = aij * b
+
+
+def ddm_irmul(a: list[list[R]], b: R) -> None:
+    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):
+    """a  <--  rref(a)"""
+    # 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_idet(a, K):
+    """a  <--  echelon(a); return det"""
+    # 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):
+    if not K.is_Field:
+        raise ValueError('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)"""
+    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)"""
+    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))"""
+    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):
+    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

env-llmeval/lib/python3.10/site-packages/sympy/polys/matrices/domainmatrix.py

@@ -0,0 +1,1791 @@
+"""
+
+Module for the DomainMatrix class.
+
+A DomainMatrix represents a matrix with elements that are in a particular
+Domain. Each DomainMatrix internally wraps a DDM which is used for the
+lower-level operations. The idea is that the DomainMatrix class provides the
+convenience routines for converting between Expr and the poly domains as well
+as unifying matrices with different domains.
+
+"""
+from functools import reduce
+from typing import Union as tUnion, Tuple as tTuple
+
+from sympy.core.sympify import _sympify
+
+from ..domains import Domain
+
+from ..constructor import construct_domain
+
+from .exceptions import (DMNonSquareMatrixError, DMShapeError,
+                         DMDomainError, DMFormatError, DMBadInputError,
+                         DMNotAField)
+
+from .ddm import DDM
+
+from .sdm import SDM
+
+from .domainscalar import DomainScalar
+
+from sympy.polys.domains import ZZ, EXRAW, QQ
+
+
+def DM(rows, domain):
+    """Convenient alias for DomainMatrix.from_list
+
+    Examples
+    =======
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DM
+    >>> DM([[1, 2], [3, 4]], ZZ)
+    DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+    See also
+    =======
+
+    DomainMatrix.from_list
+    """
+    return DomainMatrix.from_list(rows, domain)
+
+
+class DomainMatrix:
+    r"""
+    Associate Matrix with :py:class:`~.Domain`
+
+    Explanation
+    ===========
+
+    DomainMatrix uses :py:class:`~.Domain` for its internal representation
+    which makes it faster than the SymPy Matrix class (currently) for many
+    common operations, but this advantage makes it not entirely compatible
+    with Matrix. DomainMatrix are analogous to numpy arrays with "dtype".
+    In the DomainMatrix, each element has a domain such as :ref:`ZZ`
+    or  :ref:`QQ(a)`.
+
+
+    Examples
+    ========
+
+    Creating a DomainMatrix from the existing Matrix class:
+
+    >>> from sympy import Matrix
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> Matrix1 = Matrix([
+    ...    [1, 2],
+    ...    [3, 4]])
+    >>> A = DomainMatrix.from_Matrix(Matrix1)
+    >>> A
+    DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
+
+    Directly forming a DomainMatrix:
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> A = DomainMatrix([
+    ...    [ZZ(1), ZZ(2)],
+    ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    >>> A
+    DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+    See Also
+    ========
+
+    DDM
+    SDM
+    Domain
+    Poly
+
+    """
+    rep: tUnion[SDM, DDM]
+    shape: tTuple[int, int]
+    domain: Domain
+
+    def __new__(cls, rows, shape, domain, *, fmt=None):
+        """
+        Creates a :py:class:`~.DomainMatrix`.
+
+        Parameters
+        ==========
+
+        rows : Represents elements of DomainMatrix as list of lists
+        shape : Represents dimension of DomainMatrix
+        domain : Represents :py:class:`~.Domain` of DomainMatrix
+
+        Raises
+        ======
+
+        TypeError
+            If any of rows, shape and domain are not provided
+
+        """
+        if isinstance(rows, (DDM, SDM)):
+            raise TypeError("Use from_rep to initialise from SDM/DDM")
+        elif isinstance(rows, list):
+            rep = DDM(rows, shape, domain)
+        elif isinstance(rows, dict):
+            rep = SDM(rows, shape, domain)
+        else:
+            msg = "Input should be list-of-lists or dict-of-dicts"
+            raise TypeError(msg)
+
+        if fmt is not None:
+            if fmt == 'sparse':
+                rep = rep.to_sdm()
+            elif fmt == 'dense':
+                rep = rep.to_ddm()
+            else:
+                raise ValueError("fmt should be 'sparse' or 'dense'")
+
+        return cls.from_rep(rep)
+
+    def __getnewargs__(self):
+        rep = self.rep
+        if isinstance(rep, DDM):
+            arg = list(rep)
+        elif isinstance(rep, SDM):
+            arg = dict(rep)
+        else:
+            raise RuntimeError # pragma: no cover
+        return arg, self.shape, self.domain
+
+    def __getitem__(self, key):
+        i, j = key
+        m, n = self.shape
+        if not (isinstance(i, slice) or isinstance(j, slice)):
+            return DomainScalar(self.rep.getitem(i, j), self.domain)
+
+        if not isinstance(i, slice):
+            if not -m <= i < m:
+                raise IndexError("Row index out of range")
+            i = i % m
+            i = slice(i, i+1)
+        if not isinstance(j, slice):
+            if not -n <= j < n:
+                raise IndexError("Column index out of range")
+            j = j % n
+            j = slice(j, j+1)
+
+        return self.from_rep(self.rep.extract_slice(i, j))
+
+    def getitem_sympy(self, i, j):
+        return self.domain.to_sympy(self.rep.getitem(i, j))
+
+    def extract(self, rowslist, colslist):
+        return self.from_rep(self.rep.extract(rowslist, colslist))
+
+    def __setitem__(self, key, value):
+        i, j = key
+        if not self.domain.of_type(value):
+            raise TypeError
+        if isinstance(i, int) and isinstance(j, int):
+            self.rep.setitem(i, j, value)
+        else:
+            raise NotImplementedError
+
+    @classmethod
+    def from_rep(cls, rep):
+        """Create a new DomainMatrix efficiently from DDM/SDM.
+
+        Examples
+        ========
+
+        Create a :py:class:`~.DomainMatrix` with an dense internal
+        representation as :py:class:`~.DDM`:
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.matrices.ddm import DDM
+        >>> drep = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> dM = DomainMatrix.from_rep(drep)
+        >>> dM
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+        Create a :py:class:`~.DomainMatrix` with a sparse internal
+        representation as :py:class:`~.SDM`:
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import ZZ
+        >>> drep = SDM({0:{1:ZZ(1)},1:{0:ZZ(2)}}, (2, 2), ZZ)
+        >>> dM = DomainMatrix.from_rep(drep)
+        >>> dM
+        DomainMatrix({0: {1: 1}, 1: {0: 2}}, (2, 2), ZZ)
+
+        Parameters
+        ==========
+
+        rep: SDM or DDM
+            The internal sparse or dense representation of the matrix.
+
+        Returns
+        =======
+
+        DomainMatrix
+            A :py:class:`~.DomainMatrix` wrapping *rep*.
+
+        Notes
+        =====
+
+        This takes ownership of rep as its internal representation. If rep is
+        being mutated elsewhere then a copy should be provided to
+        ``from_rep``. Only minimal verification or checking is done on *rep*
+        as this is supposed to be an efficient internal routine.
+
+        """
+        if not isinstance(rep, (DDM, SDM)):
+            raise TypeError("rep should be of type DDM or SDM")
+        self = super().__new__(cls)
+        self.rep = rep
+        self.shape = rep.shape
+        self.domain = rep.domain
+        return self
+
+
+    @classmethod
+    def from_list(cls, rows, domain):
+        r"""
+        Convert a list of lists into a DomainMatrix
+
+        Parameters
+        ==========
+
+        rows: list of lists
+            Each element of the inner lists should be either the single arg,
+            or tuple of args, that would be passed to the domain constructor
+            in order to form an element of the domain. See examples.
+
+        Returns
+        =======
+
+        DomainMatrix containing elements defined in rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import FF, QQ, ZZ
+        >>> A = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], ZZ)
+        >>> A
+        DomainMatrix([[1, 0, 1], [0, 0, 1]], (2, 3), ZZ)
+        >>> B = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], FF(7))
+        >>> B
+        DomainMatrix([[1 mod 7, 0 mod 7, 1 mod 7], [0 mod 7, 0 mod 7, 1 mod 7]], (2, 3), GF(7))
+        >>> C = DomainMatrix.from_list([[(1, 2), (3, 1)], [(1, 4), (5, 1)]], QQ)
+        >>> C
+        DomainMatrix([[1/2, 3], [1/4, 5]], (2, 2), QQ)
+
+        See Also
+        ========
+
+        from_list_sympy
+
+        """
+        nrows = len(rows)
+        ncols = 0 if not nrows else len(rows[0])
+        conv = lambda e: domain(*e) if isinstance(e, tuple) else domain(e)
+        domain_rows = [[conv(e) for e in row] for row in rows]
+        return DomainMatrix(domain_rows, (nrows, ncols), domain)
+
+
+    @classmethod
+    def from_list_sympy(cls, nrows, ncols, rows, **kwargs):
+        r"""
+        Convert a list of lists of Expr into a DomainMatrix using construct_domain
+
+        Parameters
+        ==========
+
+        nrows: number of rows
+        ncols: number of columns
+        rows: list of lists
+
+        Returns
+        =======
+
+        DomainMatrix containing elements of rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.abc import x, y, z
+        >>> A = DomainMatrix.from_list_sympy(1, 3, [[x, y, z]])
+        >>> A
+        DomainMatrix([[x, y, z]], (1, 3), ZZ[x,y,z])
+
+        See Also
+        ========
+
+        sympy.polys.constructor.construct_domain, from_dict_sympy
+
+        """
+        assert len(rows) == nrows
+        assert all(len(row) == ncols for row in rows)
+
+        items_sympy = [_sympify(item) for row in rows for item in row]
+
+        domain, items_domain = cls.get_domain(items_sympy, **kwargs)
+
+        domain_rows = [[items_domain[ncols*r + c] for c in range(ncols)] for r in range(nrows)]
+
+        return DomainMatrix(domain_rows, (nrows, ncols), domain)
+
+    @classmethod
+    def from_dict_sympy(cls, nrows, ncols, elemsdict, **kwargs):
+        """
+
+        Parameters
+        ==========
+
+        nrows: number of rows
+        ncols: number of cols
+        elemsdict: dict of dicts containing non-zero elements of the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix containing elements of elemsdict
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.abc import x,y,z
+        >>> elemsdict = {0: {0:x}, 1:{1: y}, 2: {2: z}}
+        >>> A = DomainMatrix.from_dict_sympy(3, 3, elemsdict)
+        >>> A
+        DomainMatrix({0: {0: x}, 1: {1: y}, 2: {2: z}}, (3, 3), ZZ[x,y,z])
+
+        See Also
+        ========
+
+        from_list_sympy
+
+        """
+        if not all(0 <= r < nrows for r in elemsdict):
+            raise DMBadInputError("Row out of range")
+        if not all(0 <= c < ncols for row in elemsdict.values() for c in row):
+            raise DMBadInputError("Column out of range")
+
+        items_sympy = [_sympify(item) for row in elemsdict.values() for item in row.values()]
+        domain, items_domain = cls.get_domain(items_sympy, **kwargs)
+
+        idx = 0
+        items_dict = {}
+        for i, row in elemsdict.items():
+            items_dict[i] = {}
+            for j in row:
+                items_dict[i][j] = items_domain[idx]
+                idx += 1
+
+        return DomainMatrix(items_dict, (nrows, ncols), domain)
+
+    @classmethod
+    def from_Matrix(cls, M, fmt='sparse',**kwargs):
+        r"""
+        Convert Matrix to DomainMatrix
+
+        Parameters
+        ==========
+
+        M: Matrix
+
+        Returns
+        =======
+
+        Returns DomainMatrix with identical elements as M
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> M = Matrix([
+        ...    [1.0, 3.4],
+        ...    [2.4, 1]])
+        >>> A = DomainMatrix.from_Matrix(M)
+        >>> A
+        DomainMatrix({0: {0: 1.0, 1: 3.4}, 1: {0: 2.4, 1: 1.0}}, (2, 2), RR)
+
+        We can keep internal representation as ddm using fmt='dense'
+        >>> from sympy import Matrix, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix.from_Matrix(Matrix([[QQ(1, 2), QQ(3, 4)], [QQ(0, 1), QQ(0, 1)]]), fmt='dense')
+        >>> A.rep
+        [[1/2, 3/4], [0, 0]]
+
+        See Also
+        ========
+
+        Matrix
+
+        """
+        if fmt == 'dense':
+            return cls.from_list_sympy(*M.shape, M.tolist(), **kwargs)
+
+        return cls.from_dict_sympy(*M.shape, M.todod(), **kwargs)
+
+    @classmethod
+    def get_domain(cls, items_sympy, **kwargs):
+        K, items_K = construct_domain(items_sympy, **kwargs)
+        return K, items_K
+
+    def copy(self):
+        return self.from_rep(self.rep.copy())
+
+    def convert_to(self, K):
+        r"""
+        Change the domain of DomainMatrix to desired domain or field
+
+        Parameters
+        ==========
+
+        K : Represents the desired domain or field.
+            Alternatively, ``None`` may be passed, in which case this method
+            just returns a copy of this DomainMatrix.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix with the desired domain or field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, ZZ_I
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.convert_to(ZZ_I)
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ_I)
+
+        """
+        if K is None:
+            return self.copy()
+        return self.from_rep(self.rep.convert_to(K))
+
+    def to_sympy(self):
+        return self.convert_to(EXRAW)
+
+    def to_field(self):
+        r"""
+        Returns a DomainMatrix with the appropriate field
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix with the appropriate field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.to_field()
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), QQ)
+
+        """
+        K = self.domain.get_field()
+        return self.convert_to(K)
+
+    def to_sparse(self):
+        """
+        Return a sparse DomainMatrix representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
+        >>> A.rep
+        [[1, 0], [0, 2]]
+        >>> B = A.to_sparse()
+        >>> B.rep
+        {0: {0: 1}, 1: {1: 2}}
+        """
+        if self.rep.fmt == 'sparse':
+            return self
+
+        return self.from_rep(SDM.from_ddm(self.rep))
+
+    def to_dense(self):
+        """
+        Return a dense DomainMatrix representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix({0: {0: 1}, 1: {1: 2}}, (2, 2), QQ)
+        >>> A.rep
+        {0: {0: 1}, 1: {1: 2}}
+        >>> B = A.to_dense()
+        >>> B.rep
+        [[1, 0], [0, 2]]
+
+        """
+        if self.rep.fmt == 'dense':
+            return self
+
+        return self.from_rep(SDM.to_ddm(self.rep))
+
+    @classmethod
+    def _unify_domain(cls, *matrices):
+        """Convert matrices to a common domain"""
+        domains = {matrix.domain for matrix in matrices}
+        if len(domains) == 1:
+            return matrices
+        domain = reduce(lambda x, y: x.unify(y), domains)
+        return tuple(matrix.convert_to(domain) for matrix in matrices)
+
+    @classmethod
+    def _unify_fmt(cls, *matrices, fmt=None):
+        """Convert matrices to the same format.
+
+        If all matrices have the same format, then return unmodified.
+        Otherwise convert both to the preferred format given as *fmt* which
+        should be 'dense' or 'sparse'.
+        """
+        formats = {matrix.rep.fmt for matrix in matrices}
+        if len(formats) == 1:
+            return matrices
+        if fmt == 'sparse':
+            return tuple(matrix.to_sparse() for matrix in matrices)
+        elif fmt == 'dense':
+            return tuple(matrix.to_dense() for matrix in matrices)
+        else:
+            raise ValueError("fmt should be 'sparse' or 'dense'")
+
+    def unify(self, *others, fmt=None):
+        """
+        Unifies the domains and the format of self and other
+        matrices.
+
+        Parameters
+        ==========
+
+        others : DomainMatrix
+
+        fmt: string 'dense', 'sparse' or `None` (default)
+            The preferred format to convert to if self and other are not
+            already in the same format. If `None` or not specified then no
+            conversion if performed.
+
+        Returns
+        =======
+
+        Tuple[DomainMatrix]
+            Matrices with unified domain and format
+
+        Examples
+        ========
+
+        Unify the domain of DomainMatrix that have different domains:
+
+        >>> from sympy import ZZ, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+        >>> B = DomainMatrix([[QQ(1, 2), QQ(2)]], (1, 2), QQ)
+        >>> Aq, Bq = A.unify(B)
+        >>> Aq
+        DomainMatrix([[1, 2]], (1, 2), QQ)
+        >>> Bq
+        DomainMatrix([[1/2, 2]], (1, 2), QQ)
+
+        Unify the format (dense or sparse):
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+        >>> B = DomainMatrix({0:{0: ZZ(1)}}, (2, 2), ZZ)
+        >>> B.rep
+        {0: {0: 1}}
+
+        >>> A2, B2 = A.unify(B, fmt='dense')
+        >>> B2.rep
+        [[1, 0], [0, 0]]
+
+        See Also
+        ========
+
+        convert_to, to_dense, to_sparse
+
+        """
+        matrices = (self,) + others
+        matrices = DomainMatrix._unify_domain(*matrices)
+        if fmt is not None:
+            matrices = DomainMatrix._unify_fmt(*matrices, fmt=fmt)
+        return matrices
+
+    def to_Matrix(self):
+        r"""
+        Convert DomainMatrix to Matrix
+
+        Returns
+        =======
+
+        Matrix
+            MutableDenseMatrix for the DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.to_Matrix()
+        Matrix([
+            [1, 2],
+            [3, 4]])
+
+        See Also
+        ========
+
+        from_Matrix
+
+        """
+        from sympy.matrices.dense import MutableDenseMatrix
+        elemlist = self.rep.to_list()
+        elements_sympy = [self.domain.to_sympy(e) for row in elemlist for e in row]
+        return MutableDenseMatrix(*self.shape, elements_sympy)
+
+    def to_list(self):
+        return self.rep.to_list()
+
+    def to_list_flat(self):
+        return self.rep.to_list_flat()
+
+    def to_dok(self):
+        return self.rep.to_dok()
+
+    def __repr__(self):
+        return 'DomainMatrix(%s, %r, %r)' % (str(self.rep), self.shape, self.domain)
+
+    def transpose(self):
+        """Matrix transpose of ``self``"""
+        return self.from_rep(self.rep.transpose())
+
+    def flat(self):
+        rows, cols = self.shape
+        return [self[i,j].element for i in range(rows) for j in range(cols)]
+
+    @property
+    def is_zero_matrix(self):
+        return self.rep.is_zero_matrix()
+
+    @property
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return self.rep.is_upper()
+
+    @property
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return self.rep.is_lower()
+
+    @property
+    def is_square(self):
+        return self.shape[0] == self.shape[1]
+
+    def rank(self):
+        rref, pivots = self.rref()
+        return len(pivots)
+
+    def hstack(A, *B):
+        r"""Horizontally stack the given matrices.
+
+        Parameters
+        ==========
+
+        B: DomainMatrix
+            Matrices to stack horizontally.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix by stacking horizontally.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.hstack(B)
+        DomainMatrix([[1, 2, 5, 6], [3, 4, 7, 8]], (2, 4), ZZ)
+
+        >>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        DomainMatrix([[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]], (2, 6), ZZ)
+
+        See Also
+        ========
+
+        unify
+        """
+        A, *B = A.unify(*B, fmt='dense')
+        return DomainMatrix.from_rep(A.rep.hstack(*(Bk.rep for Bk in B)))
+
+    def vstack(A, *B):
+        r"""Vertically stack the given matrices.
+
+        Parameters
+        ==========
+
+        B: DomainMatrix
+            Matrices to stack vertically.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix by stacking vertically.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.vstack(B)
+        DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8]], (4, 2), ZZ)
+
+        >>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]], (6, 2), ZZ)
+
+        See Also
+        ========
+
+        unify
+        """
+        A, *B = A.unify(*B, fmt='dense')
+        return DomainMatrix.from_rep(A.rep.vstack(*(Bk.rep for Bk in B)))
+
+    def applyfunc(self, func, domain=None):
+        if domain is None:
+            domain = self.domain
+        return self.from_rep(self.rep.applyfunc(func, domain))
+
+    def __add__(A, B):
+        if not isinstance(B, DomainMatrix):
+            return NotImplemented
+        A, B = A.unify(B, fmt='dense')
+        return A.add(B)
+
+    def __sub__(A, B):
+        if not isinstance(B, DomainMatrix):
+            return NotImplemented
+        A, B = A.unify(B, fmt='dense')
+        return A.sub(B)
+
+    def __neg__(A):
+        return A.neg()
+
+    def __mul__(A, B):
+        """A * B"""
+        if isinstance(B, DomainMatrix):
+            A, B = A.unify(B, fmt='dense')
+            return A.matmul(B)
+        elif B in A.domain:
+            return A.scalarmul(B)
+        elif isinstance(B, DomainScalar):
+            A, B = A.unify(B)
+            return A.scalarmul(B.element)
+        else:
+            return NotImplemented
+
+    def __rmul__(A, B):
+        if B in A.domain:
+            return A.rscalarmul(B)
+        elif isinstance(B, DomainScalar):
+            A, B = A.unify(B)
+            return A.rscalarmul(B.element)
+        else:
+            return NotImplemented
+
+    def __pow__(A, n):
+        """A ** n"""
+        if not isinstance(n, int):
+            return NotImplemented
+        return A.pow(n)
+
+    def _check(a, op, b, ashape, bshape):
+        if a.domain != b.domain:
+            msg = "Domain mismatch: %s %s %s" % (a.domain, op, b.domain)
+            raise DMDomainError(msg)
+        if ashape != bshape:
+            msg = "Shape mismatch: %s %s %s" % (a.shape, op, b.shape)
+            raise DMShapeError(msg)
+        if a.rep.fmt != b.rep.fmt:
+            msg = "Format mismatch: %s %s %s" % (a.rep.fmt, op, b.rep.fmt)
+            raise DMFormatError(msg)
+
+    def add(A, B):
+        r"""
+        Adds two DomainMatrix matrices of the same Domain
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to add
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Addition
+
+        Raises
+        ======
+
+        DMShapeError
+            If the dimensions of the two DomainMatrix are not equal
+
+        ValueError
+            If the domain of the two DomainMatrix are not same
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(4), ZZ(3)],
+        ...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.add(B)
+        DomainMatrix([[5, 5], [5, 5]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        sub, matmul
+
+        """
+        A._check('+', B, A.shape, B.shape)
+        return A.from_rep(A.rep.add(B.rep))
+
+
+    def sub(A, B):
+        r"""
+        Subtracts two DomainMatrix matrices of the same Domain
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to subtract
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Subtraction
+
+        Raises
+        ======
+
+        DMShapeError
+            If the dimensions of the two DomainMatrix are not equal
+
+        ValueError
+            If the domain of the two DomainMatrix are not same
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(4), ZZ(3)],
+        ...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.sub(B)
+        DomainMatrix([[-3, -1], [1, 3]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        add, matmul
+
+        """
+        A._check('-', B, A.shape, B.shape)
+        return A.from_rep(A.rep.sub(B.rep))
+
+    def neg(A):
+        r"""
+        Returns the negative of DomainMatrix
+
+        Parameters
+        ==========
+
+        A : Represents a DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Negation
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.neg()
+        DomainMatrix([[-1, -2], [-3, -4]], (2, 2), ZZ)
+
+        """
+        return A.from_rep(A.rep.neg())
+
+    def mul(A, b):
+        r"""
+        Performs term by term multiplication for the second DomainMatrix
+        w.r.t first DomainMatrix. Returns a DomainMatrix whose rows are
+        list of DomainMatrix matrices created after term by term multiplication.
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to multiply term-wise
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after term by term multiplication
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.mul(B)
+        DomainMatrix([[DomainMatrix([[1, 1], [0, 1]], (2, 2), ZZ),
+        DomainMatrix([[2, 2], [0, 2]], (2, 2), ZZ)],
+        [DomainMatrix([[3, 3], [0, 3]], (2, 2), ZZ),
+        DomainMatrix([[4, 4], [0, 4]], (2, 2), ZZ)]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        matmul
+
+        """
+        return A.from_rep(A.rep.mul(b))
+
+    def rmul(A, b):
+        return A.from_rep(A.rep.rmul(b))
+
+    def matmul(A, B):
+        r"""
+        Performs matrix multiplication of two DomainMatrix matrices
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            to multiply
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after multiplication
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.matmul(B)
+        DomainMatrix([[1, 3], [3, 7]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        mul, pow, add, sub
+
+        """
+
+        A._check('*', B, A.shape[1], B.shape[0])
+        return A.from_rep(A.rep.matmul(B.rep))
+
+    def _scalarmul(A, lamda, reverse):
+        if lamda == A.domain.zero:
+            return DomainMatrix.zeros(A.shape, A.domain)
+        elif lamda == A.domain.one:
+            return A.copy()
+        elif reverse:
+            return A.rmul(lamda)
+        else:
+            return A.mul(lamda)
+
+    def scalarmul(A, lamda):
+        return A._scalarmul(lamda, reverse=False)
+
+    def rscalarmul(A, lamda):
+        return A._scalarmul(lamda, reverse=True)
+
+    def mul_elementwise(A, B):
+        assert A.domain == B.domain
+        return A.from_rep(A.rep.mul_elementwise(B.rep))
+
+    def __truediv__(A, lamda):
+        """ Method for Scalar Division"""
+        if isinstance(lamda, int) or ZZ.of_type(lamda):
+            lamda = DomainScalar(ZZ(lamda), ZZ)
+
+        if not isinstance(lamda, DomainScalar):
+            return NotImplemented
+
+        A, lamda = A.to_field().unify(lamda)
+        if lamda.element == lamda.domain.zero:
+            raise ZeroDivisionError
+        if lamda.element == lamda.domain.one:
+            return A.to_field()
+
+        return A.mul(1 / lamda.element)
+
+    def pow(A, n):
+        r"""
+        Computes A**n
+
+        Parameters
+        ==========
+
+        A : DomainMatrix
+
+        n : exponent for A
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix on computing A**n
+
+        Raises
+        ======
+
+        NotImplementedError
+            if n is negative.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.pow(2)
+        DomainMatrix([[1, 2], [0, 1]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        matmul
+
+        """
+        nrows, ncols = A.shape
+        if nrows != ncols:
+            raise DMNonSquareMatrixError('Power of a nonsquare matrix')
+        if n < 0:
+            raise NotImplementedError('Negative powers')
+        elif n == 0:
+            return A.eye(nrows, A.domain)
+        elif n == 1:
+            return A
+        elif n % 2 == 1:
+            return A * A**(n - 1)
+        else:
+            sqrtAn = A ** (n // 2)
+            return sqrtAn * sqrtAn
+
+    def scc(self):
+        """Compute the strongly connected components of a DomainMatrix
+
+        Explanation
+        ===========
+
+        A square matrix can be considered as the adjacency matrix for a
+        directed graph where the row and column indices are the vertices. In
+        this graph if there is an edge from vertex ``i`` to vertex ``j`` if
+        ``M[i, j]`` is nonzero. This routine computes the strongly connected
+        components of that graph which are subsets of the rows and columns that
+        are connected by some nonzero element of the matrix. The strongly
+        connected components are useful because many operations such as the
+        determinant can be computed by working with the submatrices
+        corresponding to each component.
+
+        Examples
+        ========
+
+        Find the strongly connected components of a matrix:
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> M = DomainMatrix([[ZZ(1), ZZ(0), ZZ(2)],
+        ...                   [ZZ(0), ZZ(3), ZZ(0)],
+        ...                   [ZZ(4), ZZ(6), ZZ(5)]], (3, 3), ZZ)
+        >>> M.scc()
+        [[1], [0, 2]]
+
+        Compute the determinant from the components:
+
+        >>> MM = M.to_Matrix()
+        >>> MM
+        Matrix([
+        [1, 0, 2],
+        [0, 3, 0],
+        [4, 6, 5]])
+        >>> MM[[1], [1]]
+        Matrix([[3]])
+        >>> MM[[0, 2], [0, 2]]
+        Matrix([
+        [1, 2],
+        [4, 5]])
+        >>> MM.det()
+        -9
+        >>> MM[[1], [1]].det() * MM[[0, 2], [0, 2]].det()
+        -9
+
+        The components are given in reverse topological order and represent a
+        permutation of the rows and columns that will bring the matrix into
+        block lower-triangular form:
+
+        >>> MM[[1, 0, 2], [1, 0, 2]]
+        Matrix([
+        [3, 0, 0],
+        [0, 1, 2],
+        [6, 4, 5]])
+
+        Returns
+        =======
+
+        List of lists of integers
+            Each list represents a strongly connected component.
+
+        See also
+        ========
+
+        sympy.matrices.matrices.MatrixBase.strongly_connected_components
+        sympy.utilities.iterables.strongly_connected_components
+
+        """
+        rows, cols = self.shape
+        assert rows == cols
+        return self.rep.scc()
+
+    def rref(self):
+        r"""
+        Returns reduced-row echelon form and list of pivots for the DomainMatrix
+
+        Returns
+        =======
+
+        (DomainMatrix, list)
+            reduced-row echelon form and list of pivots for the DomainMatrix
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [QQ(2), QQ(-1), QQ(0)],
+        ...     [QQ(-1), QQ(2), QQ(-1)],
+        ...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
+
+        >>> rref_matrix, rref_pivots = A.rref()
+        >>> rref_matrix
+        DomainMatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], (3, 3), QQ)
+        >>> rref_pivots
+        (0, 1, 2)
+
+        See Also
+        ========
+
+        convert_to, lu
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref_ddm, pivots = self.rep.rref()
+        return self.from_rep(rref_ddm), tuple(pivots)
+
+    def columnspace(self):
+        r"""
+        Returns the columnspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The columns of this matrix form a basis for the columnspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.columnspace()
+        DomainMatrix([[1], [2]], (2, 1), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref, pivots = self.rref()
+        rows, cols = self.shape
+        return self.extract(range(rows), pivots)
+
+    def rowspace(self):
+        r"""
+        Returns the rowspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The rows of this matrix form a basis for the rowspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.rowspace()
+        DomainMatrix([[1, -1]], (1, 2), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref, pivots = self.rref()
+        rows, cols = self.shape
+        return self.extract(range(len(pivots)), range(cols))
+
+    def nullspace(self):
+        r"""
+        Returns the nullspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The rows of this matrix form a basis for the nullspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.nullspace()
+        DomainMatrix([[1, 1]], (1, 2), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        return self.from_rep(self.rep.nullspace()[0])
+
+    def inv(self):
+        r"""
+        Finds the inverse of the DomainMatrix if exists
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after inverse
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        DMNonSquareMatrixError
+            If the DomainMatrix is not a not Square DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [QQ(2), QQ(-1), QQ(0)],
+        ...     [QQ(-1), QQ(2), QQ(-1)],
+        ...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
+        >>> A.inv()
+        DomainMatrix([[2/3, 1/3, 1/6], [1/3, 2/3, 1/3], [0, 0, 1/2]], (3, 3), QQ)
+
+        See Also
+        ========
+
+        neg
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError
+        inv = self.rep.inv()
+        return self.from_rep(inv)
+
+    def det(self):
+        r"""
+        Returns the determinant of a Square DomainMatrix
+
+        Returns
+        =======
+
+        S.Complexes
+            determinant of Square DomainMatrix
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.det()
+        -2
+
+        """
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError
+        return self.rep.det()
+
+    def lu(self):
+        r"""
+        Returns Lower and Upper decomposition of the DomainMatrix
+
+        Returns
+        =======
+
+        (L, U, exchange)
+            L, U are Lower and Upper decomposition of the DomainMatrix,
+            exchange is the list of indices of rows exchanged in the decomposition.
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.lu()
+        (DomainMatrix([[1, 0], [2, 1]], (2, 2), QQ), DomainMatrix([[1, -1], [0, 0]], (2, 2), QQ), [])
+
+        See Also
+        ========
+
+        lu_solve
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        L, U, swaps = self.rep.lu()
+        return self.from_rep(L), self.from_rep(U), swaps
+
+    def lu_solve(self, rhs):
+        r"""
+        Solver for DomainMatrix x in the A*x = B
+
+        Parameters
+        ==========
+
+        rhs : DomainMatrix B
+
+        Returns
+        =======
+
+        DomainMatrix
+            x in A*x = B
+
+        Raises
+        ======
+
+        DMShapeError
+            If the DomainMatrix A and rhs have different number of rows
+
+        ValueError
+            If the domain of DomainMatrix A not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(2)],
+        ...    [QQ(3), QQ(4)]], (2, 2), QQ)
+        >>> B = DomainMatrix([
+        ...    [QQ(1), QQ(1)],
+        ...    [QQ(0), QQ(1)]], (2, 2), QQ)
+
+        >>> A.lu_solve(B)
+        DomainMatrix([[-2, -1], [3/2, 1]], (2, 2), QQ)
+
+        See Also
+        ========
+
+        lu
+
+        """
+        if self.shape[0] != rhs.shape[0]:
+            raise DMShapeError("Shape")
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        sol = self.rep.lu_solve(rhs.rep)
+        return self.from_rep(sol)
+
+    def _solve(A, b):
+        # XXX: Not sure about this method or its signature. It is just created
+        # because it is needed by the holonomic module.
+        if A.shape[0] != b.shape[0]:
+            raise DMShapeError("Shape")
+        if A.domain != b.domain or not A.domain.is_Field:
+            raise DMNotAField('Not a field')
+        Aaug = A.hstack(b)
+        Arref, pivots = Aaug.rref()
+        particular = Arref.from_rep(Arref.rep.particular())
+        nullspace_rep, nonpivots = Arref[:,:-1].rep.nullspace()
+        nullspace = Arref.from_rep(nullspace_rep)
+        return particular, nullspace
+
+    def charpoly(self):
+        r"""
+        Returns the coefficients of the characteristic polynomial
+        of the DomainMatrix. These elements will be domain elements.
+        The domain of the elements will be same as domain of the DomainMatrix.
+
+        Returns
+        =======
+
+        list
+            coefficients of the characteristic polynomial
+
+        Raises
+        ======
+
+        DMNonSquareMatrixError
+            If the DomainMatrix is not a not Square DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.charpoly()
+        [1, -5, -2]
+
+        """
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError("not square")
+        return self.rep.charpoly()
+
+    @classmethod
+    def eye(cls, shape, domain):
+        r"""
+        Return identity matrix of size n
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.eye(3, QQ)
+        DomainMatrix({0: {0: 1}, 1: {1: 1}, 2: {2: 1}}, (3, 3), QQ)
+
+        """
+        if isinstance(shape, int):
+            shape = (shape, shape)
+        return cls.from_rep(SDM.eye(shape, domain))
+
+    @classmethod
+    def diag(cls, diagonal, domain, shape=None):
+        r"""
+        Return diagonal matrix with entries from ``diagonal``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import ZZ
+        >>> DomainMatrix.diag([ZZ(5), ZZ(6)], ZZ)
+        DomainMatrix({0: {0: 5}, 1: {1: 6}}, (2, 2), ZZ)
+
+        """
+        if shape is None:
+            N = len(diagonal)
+            shape = (N, N)
+        return cls.from_rep(SDM.diag(diagonal, domain, shape))
+
+    @classmethod
+    def zeros(cls, shape, domain, *, fmt='sparse'):
+        """Returns a zero DomainMatrix of size shape, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.zeros((2, 3), QQ)
+        DomainMatrix({}, (2, 3), QQ)
+
+        """
+        return cls.from_rep(SDM.zeros(shape, domain))
+
+    @classmethod
+    def ones(cls, shape, domain):
+        """Returns a DomainMatrix of 1s, of size shape, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.ones((2,3), QQ)
+        DomainMatrix([[1, 1, 1], [1, 1, 1]], (2, 3), QQ)
+
+        """
+        return cls.from_rep(DDM.ones(shape, domain))
+
+    def __eq__(A, B):
+        r"""
+        Checks for two DomainMatrix matrices to be equal or not
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            to check equality
+
+        Returns
+        =======
+
+        Boolean
+            True for equal, else False
+
+        Raises
+        ======
+
+        NotImplementedError
+            If B is not a DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+        >>> A.__eq__(A)
+        True
+        >>> A.__eq__(B)
+        False
+
+        """
+        if not isinstance(A, type(B)):
+            return NotImplemented
+        return A.domain == B.domain and A.rep == B.rep
+
+    def unify_eq(A, B):
+        if A.shape != B.shape:
+            return False
+        if A.domain != B.domain:
+            A, B = A.unify(B)
+        return A == B
+
+    def lll(A, delta=QQ(3, 4)):
+        """
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm.
+        See [1]_ and [2]_.
+
+        Parameters
+        ==========
+
+        delta : QQ, optional
+            The Lovász parameter. Must be in the interval (0.25, 1), with larger
+            values producing a more reduced basis. The default is 0.75 for
+            historical reasons.
+
+        Returns
+        =======
+
+        The reduced basis as a DomainMatrix over ZZ.
+
+        Throws
+        ======
+
+        DMValueError: if delta is not in the range (0.25, 1)
+        DMShapeError: if the matrix is not of shape (m, n) with m <= n
+        DMDomainError: if the matrix domain is not ZZ
+        DMRankError: if the matrix contains linearly dependent rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.polys.matrices import DM
+        >>> x = DM([[1, 0, 0, 0, -20160],
+        ...         [0, 1, 0, 0, 33768],
+        ...         [0, 0, 1, 0, 39578],
+        ...         [0, 0, 0, 1, 47757]], ZZ)
+        >>> y = DM([[10, -3, -2, 8, -4],
+        ...         [3, -9, 8, 1, -11],
+        ...         [-3, 13, -9, -3, -9],
+        ...         [-12, -7, -11, 9, -1]], ZZ)
+        >>> assert x.lll(delta=QQ(5, 6)) == y
+
+        Notes
+        =====
+
+        The implementation is derived from the Maple code given in Figures 4.3
+        and 4.4 of [3]_ (pp.68-69). It uses the efficient method of only calculating
+        state updates as they are required.
+
+        See also
+        ========
+
+        lll_transform
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Lenstra–Lenstra–Lovász_lattice_basis_reduction_algorithm
+        .. [2] https://web.archive.org/web/20221029115428/https://web.cs.elte.hu/~lovasz/scans/lll.pdf
+        .. [3] Murray R. Bremner, "Lattice Basis Reduction: An Introduction to the LLL Algorithm and Its Applications"
+
+        """
+        return DomainMatrix.from_rep(A.rep.lll(delta=delta))
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        """
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm
+        and returns the reduced basis and transformation matrix.
+
+        Explanation
+        ===========
+
+        Parameters, algorithm and basis are the same as for :meth:`lll` except that
+        the return value is a tuple `(B, T)` with `B` the reduced basis and
+        `T` a transformation matrix. The original basis `A` is transformed to
+        `B` with `T*A == B`. If only `B` is needed then :meth:`lll` should be
+        used as it is a little faster.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.polys.matrices import DM
+        >>> X = DM([[1, 0, 0, 0, -20160],
+        ...         [0, 1, 0, 0, 33768],
+        ...         [0, 0, 1, 0, 39578],
+        ...         [0, 0, 0, 1, 47757]], ZZ)
+        >>> B, T = X.lll_transform(delta=QQ(5, 6))
+        >>> T * X == B
+        True
+
+        See also
+        ========
+
+        lll
+
+        """
+        reduced, transform = A.rep.lll_transform(delta=delta)
+        return DomainMatrix.from_rep(reduced), DomainMatrix.from_rep(transform)

env-llmeval/lib/python3.10/site-packages/sympy/polys/matrices/domainscalar.py

@@ -0,0 +1,116 @@
+"""
+
+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 __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 __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

env-llmeval/lib/python3.10/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()
+            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()
+            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

env-llmeval/lib/python3.10/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'
+]