U ZʹjU@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 rr]/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/polys/agca/homomorphisms.py__init__8s     zModuleHomomorphism.__init__cCs|jdkr||_|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|jdkr||_|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_homcCsRt|tr |j|jkr ||Sz||j|WStk rLt YSXdSr/) r rr rr4r7r r0rNotImplementedr2rrr__mul__8s  zModuleHomomorphism.__mul__cCs6z|d|j|WStk r0tYSXdS)N)r7r r0rr:r2rrr __truediv__CszModuleHomomorphism.__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||WStk r$YdSXdS)NF)r)r r2rrr__eq__szModuleHomomorphism.__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 sz.MatrixHomomorphism.__init__..) rrlenZrankr rr0r rr containertuplematrix)rr rrUrrOrrs  zMatrixHomomorphism.__init__csHddlm}ddtjttfr,dd|fddjDjS)z=Helper function which returns a SymPy matrix ``self.matrix``.r)MatrixcSs|Sr/rrNrrrz2MatrixHomomorphism._sympy_matrix..cSs|jSr/)datarWrrrrXrYcs"g|]}fdd|DqS)csg|]}j|qSr)r Zto_sympy)rMyrrr sz?MatrixHomomorphism._sympy_matrix...rrLr6rrrr\sz4MatrixHomomorphism._sympy_matrix..)Zsympy.matricesrVr rrrrUT)rrVrr]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<)reprr_splitr rrRrangejoin)rlinestsnirrr__repr__s zMatrixHomomorphism.__repr__cCst||j|jS)r)SubModuleHomomorphismrrUrrrrrsz#MatrixHomomorphism._restrict_domaincCs||j||jS)r ) __class__r rUrrrrr!sz%MatrixHomomorphism._restrict_codomaincCs||j||j|jS)r"rnr rrUrrrrr#sz#MatrixHomomorphism._quotient_domaincsJ|j|}|jt|jtr$|jj||j|j|fdd|jDS)r$csg|] }|qSrrrLrOrrr\ sz9MatrixHomomorphism._quotient_codomain..)rr0r rrSrnr rU)rrQrrOrr%s  z%MatrixHomomorphism._quotient_codomaincCs&||j|jddt|j|jDS)NcSsg|]\}}||qSrr)rMrNr[rrrr\sz+MatrixHomomorphism._add..)rnr rziprUr2rrrr8s zMatrixHomomorphism._addcs"||j|jfdd|jDS)Ncsg|] }|qSrrrLr6rrr\sz2MatrixHomomorphism._mul_scalar..ror5rrrrr7szMatrixHomomorphism._mul_scalarcs"||jjfdd|jDS)Ncsg|] }|qSrrrLr3rrr\sz/MatrixHomomorphism._compose..ror2rrsrr4szMatrixHomomorphism._composeN)rFrGrHrIrr_rlrr!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/sz0FreeModuleHomomorphism._apply..)r r rrZsumrqrUr,rrrr.,s zFreeModuleHomomorphism._applycCs|jj|jSr/)r submodulerUrrrrr1szFreeModuleHomomorphism._imagecCs|}|jj|jSr/rZ syzygy_moduler rxgensrZsyzrrrr4s zFreeModuleHomomorphism._kernelNrFrGrHrIr.rrrrrrrtsrtc@s(eZdZdZddZddZddZdS) rma 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/rrurrrrQTsz/SubModuleHomomorphism._apply..)r r rrZrwrqrUr,rrrr.Qs zSubModuleHomomorphism._applycsjjfddjjDS)Ncsg|] }|qSrrrLrrrr\Wsz0SubModuleHomomorphism._image..)rrxr rzrrrrrVszSubModuleHomomorphism._imagecs(}jjfdd|jDS)Ncs(g|] }tddt|jjDqS)css|]\}}||VqdSr/r)rMxigirrrrQ\sz;SubModuleHomomorphism._kernel...)rwrqr rz)rMrirrrr\\sz1SubModuleHomomorphism._kernel..ryr{rrrrYs   zSubModuleHomomorphism._kernelNr|rrrrrm>srmc 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/)r0rWmodulerrrXrYz0homomorphism..freepres..cs |jSr/)r0rZrWrrrrXrYcsj|jSr/)rSr0rZrWrrrrXrYcs j|Sr/)rSr0rWrrrrXrY)r rrxrbaseZ killed_modulerrSrrrrfreepress        zhomomorphism..freeprescsg|] }|qSrrrLrrrrr\sz homomorphism..)rtr'r(r+r*) r rrUrZSFZSSZSQ_ZTFZTSZTQrrrr homomorphism`s<rN)rIZsympy.polys.agca.modulesrrrrrZsympy.polys.polyerrorsrrrKrtrmrrrrrs  -]%"