o jgU@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|ts td|t|tstd||j|jkr$td||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 rrV/var/www/html/zoom/venv/lib/python3.10/site-packages/sympy/polys/agca/homomorphisms.py__init__8s      zModuleHomomorphism.__init__cC|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_kernelrrrrkernelF  zModuleHomomorphism.kernelcCr)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\rzModuleHomomorphism.imagecCt)zCompute the kernel of ``self``.NotImplementedErrorrrrrrrzModuleHomomorphism._kernelcCr)zCompute the image of ``self``.rrrrrrvrzModuleHomomorphism._imagecCrz%Implementation of domain restriction.rrsmrrr_restrict_domainzrz#ModuleHomomorphism._restrict_domaincCrz'Implementation of codomain restriction.rr!rrr_restrict_codomain~rz%ModuleHomomorphism._restrict_codomaincCrz"Implementation of domain quotient.rr!rrr_quotient_domainrz#ModuleHomomorphism._quotient_domaincCr)$Implementation of codomain quotient.rr!rrr_quotient_codomainrz%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 r#r!rrrrestrict_domains   z"ModuleHomomorphism.restrict_domaincCs:||std||f||jkr|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%r!rrrrestrict_codomains   z$ModuleHomomorphism.restrict_codomaincCs8||std||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'r!rrrquotient_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)r!rrrquotient_codomains  z$ModuleHomomorphism.quotient_codomaincCr)zApply ``self`` to ``elem``.rrelemrrr_applyrzModuleHomomorphism._applycCs|j||j|SN)rconvertr2r r0rrr__call__szModuleHomomorphism.__call__cCr)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.) rrothrrr_composeszModuleHomomorphism._composecCr)z8Scalar multiplication. ``c`` is guaranteed in self.ring.rrcrrr _mul_scalar'rzModuleHomomorphism._mul_scalarcCr)zv Homomorphism addition. ``oth`` is guaranteed to be a homomorphism with same domain/codomain. rr6rrr_add+szModuleHomomorphism._addcCs&t|tsdS|j|jko|j|jkS)zEHelper to check that oth is a homomorphism with same domain/codomain.F)r rr rr6rrr _check_hom2s zModuleHomomorphism._check_homcCsLt|tr|j|jkr||Sz ||j|WSty%t YSwr3) r rr rr8r;r r4rNotImplementedr6rrr__mul__8s  zModuleHomomorphism.__mul__cCs0z |d|j|WStytYSw)N)r;r r4rr>r6rrr __truediv__Cs  zModuleHomomorphism.__truediv__cCs||r ||StSr3)r=r<r>r6rrr__add__Is  zModuleHomomorphism.__add__cCs&||r|||jdStS)N)r=r<r;r r4r>r6rrr__sub__Ns zModuleHomomorphism.__sub__cC |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_injectiveSs zModuleHomomorphism.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 )rFrGrrrris_isomorphismsz!ModuleHomomorphism.is_isomorphismcCrE)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-s zModuleHomomorphism.is_zerocCs$z||WStyYdSw)NF)r-r r6rrr__eq__s  zModuleHomomorphism.__eq__cCs ||k Sr3rr6rrr__ne__s zModuleHomomorphism.__ne__N)"__name__ __module__ __qualname____doc__rrrrrr#r%r'r)r+r,r.r/r2r5r8r;r<r=r?__rmul__rArBrDrFrGrHr-rIrJrrrrrs@%' &   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||jkrtd|jt|f|jjt|jtt fr*|jj jt fdd|D|_ dS)Nz#Need to provide %s elements, got %sc3s|]}|VqdSr3r.0x converterrr sz.MatrixHomomorphism.__init__..) rrlenrankr rr4r rr containertuplematrix)rr rr[rrTrrs  zMatrixHomomorphism.__init__csHddlm}ddtjttfrdd|fddjDjS)z=Helper function which returns a SymPy matrix ``self.matrix``.r)MatrixcSs|Sr3rrSrrrsz2MatrixHomomorphism._sympy_matrix..cSs|jSr3)datar]rrrr^scs"g|] }fdd|DqS)csg|]}j|qSr)r to_sympy)rRyrrr z?MatrixHomomorphism._sympy_matrix...rrQr:rrrrbs"z4MatrixHomomorphism._sympy_matrix..)sympy.matricesr\r rrrr[T)rr\rrdr _sympy_matrixs z MatrixHomomorphism._sympy_matrixcCst|d}d|j|jf}dt|}t|}t|dD] }|||7<q!||d|7<t|dd|D] }|||7<q?d|S)N z : %s -> %s r@)reprrgsplitr rrWrangejoin)rlinestsnirrr__repr__s  zMatrixHomomorphism.__repr__cCst||j|jSr )SubModuleHomomorphismrr[r!rrrr#sz#MatrixHomomorphism._restrict_domaincCs||j||jSr$) __class__r r[r!rrrr%sz%MatrixHomomorphism._restrict_codomaincCs||j||j|jSr&rvr rr[r!rrrr'sz#MatrixHomomorphism._quotient_domaincsJ|j|}|jt|jtr|jj||j|j|fdd|jDS)r(cg|]}|qSrrrQrTrrrb z9MatrixHomomorphism._quotient_codomain..)rr4r rrYrvr r[)rr"QrrTrr)s  z%MatrixHomomorphism._quotient_codomaincCs&||j|jddt|j|jDS)NcSsg|]\}}||qSrr)rRrSrarrrrbrcz+MatrixHomomorphism._add..)rvr rzipr[r6rrrr<s zMatrixHomomorphism._addcs"||j|jfdd|jDS)Ncsg|]}|qSrrrQr:rrrbryz2MatrixHomomorphism._mul_scalar..rwr9rr|rr;"zMatrixHomomorphism._mul_scalarcs"||jjfdd|jDS)NcrxrrrQr7rrrbryz/MatrixHomomorphism._compose..rwr6rr~rr8r}zMatrixHomomorphism._composeN)rKrLrMrNrrgrtr#r%r'r)r<r;r8rrrrrPs    rPc@(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]]) cC,t|jtr |j}tddt||jDS)Ncs|] \}}||VqdSr3rrRrSerrrrV/z0FreeModuleHomomorphism._apply..)r r rr_sumr{r[r0rrrr2, zFreeModuleHomomorphism._applycCs|jj|jSr3)r submoduler[rrrrr1szFreeModuleHomomorphism._imagecCs|}|jj|jSr3r syzygy_moduler rgensrsyzrrrr4s zFreeModuleHomomorphism._kernelNrKrLrMrNr2rrrrrrr  rc@r) rua 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]]) cCr)Ncsrr3rrrrrrVTrz/SubModuleHomomorphism._apply..)r r rr_rr{r[r0rrrr2QrzSubModuleHomomorphism._applycsjjfddjjDS)NcrxrrrQrrrrbWryz0SubModuleHomomorphism._image..)rrr rrrrrrVszSubModuleHomomorphism._imagecs(}jjfdd|jDS)Ncs(g|]}tddt|jjDqS)csrr3r)rRxigirrrrV\rz;SubModuleHomomorphism._kernel...)rr{r r)rRrqrrrrb\s z1SubModuleHomomorphism._kernel..rrrrrrYs  zSubModuleHomomorphism._kernelNrrrrrru>rruc 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]> csttrfddfSttr#jjjfddfSttr6jjjjfddfSjfddfS)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 |Sr3)r4r]modulerrr^s z0homomorphism..freepres..cs |jSr3)r4r_r]rrrr^ csj|jSr3)rYr4r_r]rrrr^scs j|Sr3)rYr4r]rrrr^r)r rrrbase killed_modulerrYrrrrfreepress        zhomomorphism..freeprescrxrrrQr|rrrbryz homomorphism..)rr+r,r/r.) r rr[rSFSSSQ_TFTSTQrr|r homomorphism`s<  rN)rNsympy.polys.agca.modulesrrrrrsympy.polys.polyerrorsrrrPrrurrrrrs -]% "