Add files using upload-large-folder tool

.gitattributes

@@ -188,3 +188,4 @@ env-llmeval/lib/python3.10/site-packages/pyarrow/libarrow_flight.so.1500 filter=
 llmeval-env/lib/python3.10/site-packages/scipy/stats/_unuran/unuran_wrapper.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_adv_infer.so.8 filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/nvidia/nccl/lib/libnccl.so.2 filter=lfs diff=lfs merge=lfs -text
+llmeval-env/lib/python3.10/site-packages/nvidia/cusparse/lib/libcusparse.so.12 filter=lfs diff=lfs merge=lfs -text

llmeval-env/lib/python3.10/site-packages/nvidia/cusparse/lib/libcusparse.so.12

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:500466a2f559de622a71bb920d3d2923e69135245747a2742ee13edff0ba6085
+size 264876688

llmeval-env/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']

llmeval-env/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

llmeval-env/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)

llmeval-env/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]

llmeval-env/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)