ó ¡¼™\c@ sÉdZddlmZmZddlmZddlmZmZm Z m Z m Z ddl m Z defd„ƒYZdefd „ƒYZd efd „ƒYZd efd „ƒYZd„ZdS(s  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. iÿÿÿÿ(tprint_functiontdivision(trange(tModulet FreeModuletQuotientModulet SubModuletSubQuotientModule(tCoercionFailedtModuleHomomorphismcB seZdZd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z d „Z d „Z d „Z d „Zd „Zd„Zd„Zd„Zd„Zd„Zd„Zd„ZeZd„ZeZd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z!RS(s" 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 cC s£t|tƒs"td|ƒ‚nt|tƒsDtd|ƒ‚n|j|jkrotd||fƒ‚n||_||_|j|_d|_d|_ dS(NsSource must be a module, got %ssTarget must be a module, got %ss8Source and codomain must be over same ring, got %s != %s( t isinstanceRt TypeErrortringt ValueErrortdomaintcodomaintNonet_kert_img(tselfRR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__init__:s    cC s(|jdkr!|jƒ|_n|jS(sî 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(RRt_kernel(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytkernelHscC s(|jdkr!|jƒ|_n|jS(sú 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(RRt_image(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytimage^scC s t‚dS(sCompute the kernel of ``self``.N(tNotImplementedError(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRtscC s t‚dS(sCompute the image of ``self``.N(R(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRxscC s t‚dS(s%Implementation of domain restriction.N(R(Rtsm((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_restrict_domain|scC s t‚dS(s'Implementation of codomain restriction.N(R(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_restrict_codomain€scC s t‚dS(s"Implementation of domain quotient.N(R(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_quotient_domain„scC s t‚dS(s$Implementation of codomain quotient.N(R(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_quotient_codomainˆscC sN|jj|ƒs.td|j|fƒ‚n||jkrA|S|j|ƒS(s? 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]]) s$sm must be a submodule of %s, got %s(Rt is_submoduleR R(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytrestrict_domainŒs cC sT|j|jƒƒs4td|jƒ|fƒ‚n||jkrG|S|j|ƒS(s„ 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]]) s$the image %s must contain sm, got %s(RRR RR(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytrestrict_codomain³s cC sQ|jƒj|ƒs4td|jƒ|fƒ‚n|jƒrD|S|j|ƒS(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]]) s!kernel %s must contain sm, got %s(RRR tis_zeroR(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytquotient_domainÓs  cC sK|jj|ƒs.td|j|fƒ‚n|jƒr>|S|j|ƒS(s: 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]]) s-sm must be a submodule of codomain %s, got %s(RRR R"R(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytquotient_codomainòs  cC s t‚dS(sApply ``self`` to ``elem``.N(R(Rtelem((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_applyscC s%|jj|j|jj|ƒƒƒS(N(RtconvertR&R(RR%((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__call__scC s t‚dS(s  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.) N(R(Rtoth((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_composescC s t‚dS(s8Scalar multiplication. ``c`` is guaranteed in self.ring.N(R(Rtc((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt _mul_scalar)scC s t‚dS(sv Homomorphism addition. ``oth`` is guaranteed to be a homomorphism with same domain/codomain. N(R(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt_add-scC s5t|tƒstS|j|jko4|j|jkS(sEHelper to check that oth is a homomorphism with same domain/codomain.(R R tFalseRR(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt _check_hom4scC sdt|tƒr.|j|jkr.|j|ƒSy|j|jj|ƒƒSWntk r_t SXdS(N( R R RRR*R,R R'RtNotImplemented(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__mul__:s !  cC s:y!|jd|jj|ƒƒSWntk r5tSXdS(Ni(R,R R'RR0(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__div__Es! cC s |j|ƒr|j|ƒStS(N(R/R-R0(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__add__Ms cC s5|j|ƒr1|j|j|jjdƒƒƒStS(Niÿÿÿÿ(R/R-R,R R'R0(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__sub__Rs"cC s|jƒjƒS(s 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"(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt is_injectiveWscC s|jƒ|jkS(s 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 (RR(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt is_surjectivenscC s|jƒo|jƒS(s~ 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 (R5R6(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytis_isomorphism…scC s|jƒjƒS(sN 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"(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR"scC s+y||jƒSWntk r&tSXdS(N(R"R R.(RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__eq__¶s cC s ||k S(N((RR)((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__ne__¼s("t__name__t __module__t__doc__RRRRRRRRRR R!R#R$R&R(R*R,R-R/R1t__rmul__R2t __truediv__R3R4R5R6R7R"R8R9(((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR s@$          '  &              tMatrixHomomorphismcB sheZdZd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z d „Z d „Z RS( sí 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 c s£tj|||ƒt|ƒ|jkrJtd|jt|ƒfƒ‚n|jj‰t|jtt fƒr€|jj j‰nt ‡fd†|Dƒƒ|_ dS(Ns#Need to provide %s elements, got %sc3 s|]}ˆ|ƒVqdS(N((t.0tx(t converter(s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pys çs( R RtlentrankR RR'R RRt containerttupletmatrix(RRRRG((RBs=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRÞs cC s…ddlm}d„}t|jttfƒr=d„}n|g|jD]1}g||ƒD]}|jj|ƒ^q]^qJƒj S(s=Helper function which returns a sympy matrix ``self.matrix``.iÿÿÿÿ(tMatrixcS s|S(N((RA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytìtcS s|jS(N(tdata(RA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRIîRJ( tsympy.matricesRHR RRRRGR tto_sympytT(RRHR+RAty((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt _sympy_matrixés   cC sËt|jƒƒjdƒ}d|j|jf}dt|ƒ}t|ƒ}x(t|dƒD]}||c|7 %st ii(treprRPtsplitRRRCRtjoin(Rtlinestttstnti((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt__repr__ñs cC st||j|jƒS(s%Implementation of domain restriction.(tSubModuleHomomorphismRRG(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRýscC s|j|j||jƒS(s'Implementation of codomain restriction.(t __class__RRG(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRscC s |j|j||j|jƒS(s"Implementation of domain quotient.(R\RRRG(RR((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRscC sp|j|}|j}t|jtƒr7|jj}n|j|j|j|g|jD]}||ƒ^qWƒS(s$Implementation of codomain quotient.(RR'R RRER\RRG(RRtQRBRA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR s   cC sE|j|j|jgt|j|jƒD]\}}||^q(ƒS(N(R\RRtzipRG(RR)RARO((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR-scC s3|j|j|jg|jD]}||^qƒS(N(R\RRRG(RR+RA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR,scC s5|j|j|jg|jD]}||ƒ^qƒS(N(R\RRRG(RR)RA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR*s( R:R;R<RRPRZRRRRR-R,R*(((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR?Às      tFreeModuleHomomorphismcB s)eZdZd„Zd„Zd„ZRS(sð 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 s>t|jtƒr|j}ntd„t||jƒDƒƒS(Ncs s|]\}}||VqdS(N((R@RAte((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pys 3s(R RRRKtsumR^RG(RR%((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR&0s cC s|jj|jŒS(N(Rt submoduleRG(R((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR5scC s%|jƒjƒ}|jj|jŒS(N(Rt syzygy_moduleRRbtgens(Rtsyz((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR8s(R:R;R<R&RR(((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR_s  R[cB s)eZdZd„Zd„Zd„ZRS(s 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]]) cC s>t|jtƒr|j}ntd„t||jƒDƒƒS(Ncs s|]\}}||VqdS(N((R@RAR`((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pys Xs(R RRRKRaR^RG(RR%((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR&Us cC s/|jjg|jjD]}||ƒ^qŒS(N(RRbRRd(RRA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRZscC sW|jƒjƒ}|jjg|jD]+}td„t||jjƒDƒƒ^q%ŒS(Ncs s|]\}}||VqdS(N((R@txitgi((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pys `s(RRcRRbRdRaR^(RReRW((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR]s (R:R;R<R&RR(((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyR[Bs  c C s†d„}||ƒ\}}}}||ƒ\}} } } t||g|D]} | | ƒ^qIƒj|ƒj| ƒj| ƒj|ƒS(s> 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]> c sµtˆtƒr.ˆˆˆjƒ‡fd†fStˆtƒr_ˆjˆjˆj‡fd†fStˆtƒr“ˆjjˆjˆj‡fd†fSˆjˆˆjƒ‡fd†fS(sÞ 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. c s ˆj|ƒS(N(R'(RA(tmodule(s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRI§RJc sˆj|ƒjS(N(R'RK(RA(Rh(s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRIªRJc sˆjj|ƒjS(N(RER'RK(RA(Rh(s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRI­RJc sˆjj|ƒS(N(RER'(RA(Rh(s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyRI°RJ(R RRbRtbaset killed_moduleRRE(Rh((Rhs=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pytfreepres s(R_R R!R$R#( RRRGRktSFtSStSQt_tTFtTStTQR+RA((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyt homomorphismds < +N(R<t __future__RRtsympy.core.compatibilityRtsympy.polys.agca.modulesRRRRRtsympy.polys.polyerrorsRtobjectR R?R_R[Rs(((s=lib/python2.7/site-packages/sympy/polys/agca/homomorphisms.pyts(ÿ­]%"