a RG5dU@svdZddlmZmZmZmZmZddlmZGdddZ Gddde Z Gdd d e Z Gd d d e Z d d Z dS)a  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. )Module FreeModuleQuotientModule SubModuleSubQuotientModule)CoercionFailedc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)ZeZd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Z d:d;Z!d>> 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 cCslt|tstd|t|ts,td||j|jkrHtd||f||_||_|j|_d|_d|_dS)NzSource must be a module, got %szTarget must be a module, got %sz8Source and codomain must be over same ring, got %s != %s) isinstancer TypeErrorring ValueErrordomaincodomain_ker_img)selfr rrZ/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/polys/agca/homomorphisms.py__init__8s     zModuleHomomorphism.__init__cCs|jdur||_|jS)a 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]> N)r_kernelrrrrkernelFs  zModuleHomomorphism.kernelcCs|jdur||_|jS)a 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 N)r_imagerrrrimage\s  zModuleHomomorphism.imagecCstdS)zCompute the kernel of ``self``.NNotImplementedErrorrrrrrrszModuleHomomorphism._kernelcCstdS)zCompute the image of ``self``.NrrrrrrvszModuleHomomorphism._imagecCstdS)%Implementation of domain restriction.Nrrsmrrr_restrict_domainzsz#ModuleHomomorphism._restrict_domaincCstdS)'Implementation of codomain restriction.Nrrrrr_restrict_codomain~sz%ModuleHomomorphism._restrict_codomaincCstdS)"Implementation of domain quotient.Nrrrrr_quotient_domainsz#ModuleHomomorphism._quotient_domaincCstdS)$Implementation of codomain quotient.Nrrrrr_quotient_codomainsz%ModuleHomomorphism._quotient_codomaincCs6|j|std|j|f||jkr,|S||S)a? 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]]) z$sm must be a submodule of %s, got %s)r is_submoduler rrrrrrestrict_domains  z"ModuleHomomorphism.restrict_domaincCs:||s"td||f||jkr0|S||S)a 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]]) z$the image %s must contain sm, got %s)r&rr rr!rrrrrestrict_codomains  z$ModuleHomomorphism.restrict_codomaincCs8||s"td||f|r.|S||S)am 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]]) z!kernel %s must contain sm, got %s)rr&r is_zeror#rrrrquotient_domains z"ModuleHomomorphism.quotient_domaincCs4|j|std|j|f|r*|S||S)a: 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]]) z-sm must be a submodule of codomain %s, got %s)rr&r r)r%rrrrquotient_codomains z$ModuleHomomorphism.quotient_codomaincCstdS)zApply ``self`` to ``elem``.Nrrelemrrr_applyszModuleHomomorphism._applycCs|j||j|SN)rconvertr.r r,rrr__call__szModuleHomomorphism.__call__cCstdS)a  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.) Nrrothrrr_composeszModuleHomomorphism._composecCstdS)z8Scalar multiplication. ``c`` is guaranteed in self.ring.Nrrcrrr _mul_scalar'szModuleHomomorphism._mul_scalarcCstdS)zv Homomorphism addition. ``oth`` is guaranteed to be a homomorphism with same domain/codomain. Nrr2rrr_add+szModuleHomomorphism._addcCs&t|tsdS|j|jko$|j|jkS)zEHelper to check that oth is a homomorphism with same domain/codomain.F)r rr rr2rrr _check_hom2s zModuleHomomorphism._check_homcCsPt|tr |j|jkr ||Sz||j|WStyJt YS0dSr/) r rr rr4r7r r0rNotImplementedr2rrr__mul__8s   zModuleHomomorphism.__mul__cCs4z|d|j|WSty.tYS0dS)N)r7r r0rr:r2rrr __truediv__Cs zModuleHomomorphism.__truediv__cCs||r||StSr/)r9r8r:r2rrr__add__Is  zModuleHomomorphism.__add__cCs&||r"|||jdStS)N)r9r8r7r r0r:r2rrr__sub__Ns zModuleHomomorphism.__sub__cCs |S)a 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 )rr)rrrr is_injectiveSszModuleHomomorphism.is_injectivecCs||jkS)a 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 )rrrrrr is_surjectivejsz ModuleHomomorphism.is_surjectivecCs|o|S)a~ 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 )rArBrrrris_isomorphismsz!ModuleHomomorphism.is_isomorphismcCs |S)aN 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 )rr)rrrrr)szModuleHomomorphism.is_zerocCs(z||WSty"YdS0dS)NF)r)r r2rrr__eq__s zModuleHomomorphism.__eq__cCs ||k Sr/rr2rrr__ne__szModuleHomomorphism.__ne__N)"__name__ __module__ __qualname____doc__rrrrrrr!r#r%r'r(r*r+r.r1r4r7r8r9r;__rmul__r=r>r@rArBrCr)rDrErrrrrs>%' &  rc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS)MatrixHomomorphisma 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 cspt|||t||jkr2td|jt|f|jjt|jtt frT|jj jt fdd|D|_ dS)Nz#Need to provide %s elements, got %sc3s|]}|VqdSr/r.0x converterrr z.MatrixHomomorphism.__init__..) rrlenrankr rr0r rr containertuplematrix)rr rrWrrOrrs  zMatrixHomomorphism.__init__csHddlm}ddtjttfr,dd|fddjDjS)z=Helper function which returns a SymPy matrix ``self.matrix``.r)MatrixcSs|Sr/rrNrrrrRz2MatrixHomomorphism._sympy_matrix..cSs|jSr/)datarYrrrrZrRcs"g|]}fdd|DqS)csg|]}j|qSr)r to_sympy)rMyrrr rRz?MatrixHomomorphism._sympy_matrix...rrLr6rrrr^rRz4MatrixHomomorphism._sympy_matrix..)sympy.matricesrXr rrrrWT)rrXrr_r _sympy_matrixs  z MatrixHomomorphism._sympy_matrixcCst|d}d|j|jf}dt|}t|}t|dD]}|||7<qB||d|7<t|dd|D]}|||7<q~d|S)N z : %s -> %s r<)reprrbsplitr rrSrangejoin)rlinestsnirrr__repr__s zMatrixHomomorphism.__repr__cCst||j|jS)r)SubModuleHomomorphismrrWrrrrrsz#MatrixHomomorphism._restrict_domaincCs||j||jS)r ) __class__r rWrrrrr!sz%MatrixHomomorphism._restrict_codomaincCs||j||j|jS)r"rqr rrWrrrrr#sz#MatrixHomomorphism._quotient_domaincsJ|j|}|jt|jtr$|jj||j|j|fdd|jDS)r$csg|] }|qSrrrLrOrrr^ rRz9MatrixHomomorphism._quotient_codomain..)rr0r rrUrqr rW)rrQrrOrr%s  z%MatrixHomomorphism._quotient_codomaincCs&||j|jddt|j|jDS)NcSsg|]\}}||qSrr)rMrNr]rrrr^rRz+MatrixHomomorphism._add..)rqr rziprWr2rrrr8s zMatrixHomomorphism._addcs"||j|jfdd|jDS)Ncsg|] }|qSrrrLr6rrr^rRz2MatrixHomomorphism._mul_scalar..rrr5rrurr7szMatrixHomomorphism._mul_scalarcs"||jjfdd|jDS)Ncsg|] }|qSrrrLr3rrr^rRz/MatrixHomomorphism._compose..rrr2rrvrr4szMatrixHomomorphism._composeN)rFrGrHrIrrbrorr!r#r%r8r7r4rrrrrKs   rKc@s(eZdZdZddZddZddZdS) FreeModuleHomomorphisma 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]]) cCs,t|jtr|j}tddt||jDS)Ncss|]\}}||VqdSr/rrMrNerrrrQ/rRz0FreeModuleHomomorphism._apply..)r r rr[sumrtrWr,rrrr.,s zFreeModuleHomomorphism._applycCs|jj|jSr/)r submodulerWrrrrr1szFreeModuleHomomorphism._imagecCs|}|jj|jSr/rZ syzygy_moduler r{gensrZsyzrrrr4s zFreeModuleHomomorphism._kernelNrFrGrHrIr.rrrrrrrwsrwc@s(eZdZdZddZddZddZdS) rpa 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]]) cCs,t|jtr|j}tddt||jDS)Ncss|]\}}||VqdSr/rrxrrrrQTrRz/SubModuleHomomorphism._apply..)r r rr[rzrtrWr,rrrr.Qs zSubModuleHomomorphism._applycsjjfddjjDS)Ncsg|] }|qSrrrLrrrr^WrRz0SubModuleHomomorphism._image..)rr{r r}rrrrrVszSubModuleHomomorphism._imagecs(}jjfdd|jDS)Ncs(g|] }tddt|jjDqS)css|]\}}||VqdSr/r)rMxigirrrrQ\rRz;SubModuleHomomorphism._kernel...)rzrtr r})rMrlrrrr^\sz1SubModuleHomomorphism._kernel..r|r~rrrrYs   zSubModuleHomomorphism._kernelNrrrrrrp>srpc sZdd}||\}}}}||\}} } t||fdd|D|| | |S)a> 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]> csttr"fddfSttrFjjjfddfSttrljjjjfddfSjfddfS)z 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. cs |Sr/)r0rYmodulerrrZrRz0homomorphism..freepres..cs |jSr/)r0r[rYrrrrZrRcsj|jSr/)rUr0r[rYrrrrZrRcs j|Sr/)rUr0rYrrrrZrR)r rr{rbase killed_modulerrUrrrrfreepress        zhomomorphism..freeprescsg|] }|qSrrrLrurrr^rRz homomorphism..)rwr'r(r+r*) r rrWrZSFZSSZSQ_ZTFZTSZTQrrur homomorphism`s<rN)rIZsympy.polys.agca.modulesrrrrrsympy.polys.polyerrorsrrrKrwrprrrrrs  -]%"