o jg@sTdZddlmZddlmZddlmZddlmZddlm Z m Z ddl m Z ddl mZdd lmZdd lmZGd d d ZGd ddZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZddZddZGddde ZGd d!d!eZGd"d#d#eZGd$d%d%eZ Gd&d'd'eZ!d(S))ao 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. )copy)reduce)Ideal)Field) ProductOrder monomial_key)DMP)CoercionFailed)_aresame)iterablec@seZdZdZddZd!ddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZeZdd ZdS)"Modulea 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. cCs ||_dSN)ring)selfrrP/var/www/html/zoom/venv/lib/python3.10/site-packages/sympy/polys/agca/modules.py__init__G zModule.__init__NcCst||jst|S)z Convert ``elem`` into internal representation of this module. If ``M`` is not None, it should be a module containing it. ) isinstancedtyper relemMrrrconvertJs zModule.convertcGt)zGenerate a submodule.NotImplementedErrorrgensrrr submoduleTzModule.submodulecCr)zGenerate a quotient module.rrotherrrrquotient_moduleXr zModule.quotient_modulecCst|ts |j|}||Sr )rr rr#rerrr __truediv__\s   zModule.__truediv__cCs&z||WdStyYdSw)z5Return True if ``elem`` is an element of this module.TF)rr rrrrrcontainsas   zModule.containscC ||Sr r(r'rrr __contains__irzModule.__contains__ctfdd|DS)aN 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 c3|]}|VqdSr r*.0xrrr {z Module.subset..allr!rr1rsubsetlsz Module.subsetcCs||o ||Sr ) is_submoduler!rrr__eq__}z Module.__eq__cC ||k Sr rr!rrr__ne__rz Module.__ne__cCr)z*Returns True if ``self`` is a zero module.rr1rrris_zeror zModule.is_zerocCr)z5Returns True if ``other`` is a submodule of ``self``.rr!rrrr7r zModule.is_submodulecCr)z; Multiply ``self`` by the ideal ``other``. rr!rrrmultiply_idealszModule.multiply_idealc Cs@t|tsz|j|}Wn ttfytYSw||Sr )rrridealr rNotImplementedr=r$rrr__mul__s  zModule.__mul__cCr)z-Return the identity homomorphism on ``self``.rr1rrr identity_homr zModule.identity_homr )__name__ __module__ __qualname____doc__rrrr#r&r(r+r6r8r;r<r7r=r@__rmul__rArrrrr ,s$   r c@seZdZdZddZddZddZdd Zd d Zd d Z e Z ddZ ddZ ddZ ddZeZddZddZddZdS) ModuleElementa 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 cCs||_||_dSr )moduledata)rrHrIrrrrs zModuleElement.__init__cCs||S)zAdd data ``d1`` and ``d2``.rrd1d2rrraddzModuleElement.addcCs||S)z,Multiply module data ``m`` by coefficient d.rrmdrrrmulrNzModuleElement.mulcCs||S)z*Divide module data ``m`` by coefficient d.rrOrrrdivrNzModuleElement.divcCs||kS)z4Return true if d1 and d2 represent the same element.rrJrrreqrNzModuleElement.eqcCsZt||jr |j|jkr z|j|}Wn tytYSw||j||j|jSr )r __class__rHrr r?rMrIromrrr__add__s zModuleElement.__add__c Cs"||j||j|jjdS)N)rUrHrRrIrrr1rrr__neg__s zModuleElement.__neg__cCsLt||jr |j|jkr z|j|}Wn tytYSw|| Sr )rrUrHrr r?rXrVrrr__sub__s  zModuleElement.__sub__cCs | |Sr )rXrVrrr__rsub__s zModuleElement.__rsub__cCRt||jjjsz |jj|}Wn tytYSw||j||j |Sr ) rrHrrrr r?rUrRrIrorrrr@ zModuleElement.__mul__cCr]r ) rrHrrrr r?rUrSrIr^rrrr&r`zModuleElement.__truediv__cCsNt||jr |j|jkrz|j|}Wn tyYdSw||j|jSNF)rrUrHrr rTrIrVrrrr8s zModuleElement.__eq__cCr:r rrVrrrr;rzModuleElement.__ne__N)rBrCrDrErrMrRrSrTrX__radd__rZr[r\r@rFr&r8r;rrrrrGs" rGc@@eZdZdZddZddZddZdd Zd d Zd d Z dS)FreeModuleElementz1Element of a free module. Data stored as a tuple.cCstddt||DS)Ncss|] \}}||VqdSr r)r/r0yrrrr2z(FreeModuleElement.add..)tupleziprJrrrrMzFreeModuleElement.addcr,)Nc3s|]}|VqdSr rr.prrr2 z(FreeModuleElement.mul..rgrrQrkrrjrrR zFreeModuleElement.mulcr,)Nc3s|]}|VqdSr rr.rjrrr2rlz(FreeModuleElement.div..rmrnrrjrrS rozFreeModuleElement.divcsVddlmj}tdd|Drfdd|D}ddfd d|Dd S) Nrsstrcss|]}t|tVqdSr )rrr.rrrr2r3z-FreeModuleElement.__repr__..csg|] }jj|qSr)rHrto_sympyr.r1rr z.FreeModuleElement.__repr__..[, c3s|]}|VqdSr rr.rprrr2rl])sympy.printing.strrqrIanyjoin)rrIr)rrqr__repr__s  zFreeModuleElement.__repr__cC |jSr )rI__iter__r1rrrr}rzFreeModuleElement.__iter__cCs |j|Sr rI)ridxrrr __getitem__rzFreeModuleElement.__getitem__N) rBrCrDrErMrRrSr{r}rrrrrrds rdc@s^eZdZdZeZddZddZddZdd d Z d d Z d dZ ddZ ddZ ddZdS) FreeModulez Abstract base class for free modules. Additional attributes: - rank - rank of the free module Non-implemented methods: - submodule cCst||||_dSr )r rrank)rrrrrrr-s  zFreeModule.__init__cCt|jdt|jS)N**reprrrr1rrrr{1rizFreeModule.__repr__cCs:t|tr |j|kSt|tr|j|jko|j|jkSdS)a 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 F)r SubModule containerrrrr!rrrr74s   zFreeModule.is_submoduleNcsttr%jur SjjjkrtttfddjDStrBtfddD}t|jkr=tt|St drTtj dfjSt)a 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] c3s"|] }j|jjVqdSr )rrrHr.rrrrr2b z%FreeModule.convert..c3s|] }j|VqdSr )rrr.r1rrr2drfr) rrdrHrr rgrIr lenr rr)rrrtplrrrrLs    zFreeModule.convertcCs |jdkS)a 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 r)rr1rrrr<ms zFreeModule.is_zerocs4ddlm}|jtfddtjDS)z 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]) r)eyec3s |] }|VqdSr )rrowr/irrrrr2sz#FreeModule.basis..)sympy.matricesrrrgrange)rrrrrbasiss zFreeModule.basiscCst|j||S)a 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]> )QuotientModuler)rrrrrr#szFreeModule.quotient_modulecCs|j||S)a= 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]> )rrr=r!rrrr=szFreeModule.multiply_idealcCsddlm}||||S)a/ 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]]) r) homomorphism)sympy.polys.agca.homomorphismsrr)rrrrrrAs zFreeModule.identity_homr )rBrCrDrErdrrr{r7rr<rr#r=rArrrrrs  ! rc@ eZdZdZddZddZdS)FreeModulePolyRingaw 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 cCsVddlm}t|||t||stdd|t|jts)tdd|jdS)Nr)PolynomialRingBase$This implementation only works over zpolynomial rings, got %szGround domain must be a field, zgot %s)&sympy.polys.domains.old_polynomialringrrrrrdomr)rrrrrrrrs   zFreeModulePolyRing.__init__cOt||fi|S)ae 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 )SubModulePolyRingrroptsrrrrzFreeModulePolyRing.submoduleN)rBrCrDrErrrrrrrs rc@s8eZdZdZddZddZddZdd Zd d Zd S) FreeModuleQuotientRinga 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]/)**3 Attributes - quot - the quotient module `R^n / IR^n`, where `R/I` is our ring cCsZddlm}t|||t||stdd||jj|j}||jj ||_ dS)Nr) QuotientRingrzquotient rings, got %s) sympy.polys.domains.quotientringrrrrrr free_moduler base_idealquot)rrrrFrrrr s  zFreeModuleQuotientRing.__init__cCs dt|jddt|jS)N()rrr1rrrr{s zFreeModuleQuotientRing.__repr__cOr)a 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 + y + ]> >>> M.contains([y**2, x**2 + x*y]) True >>> M.contains([x, y]) False )SubModuleQuotientRingrrrrrrz FreeModuleQuotientRing.submodulecCs|jdd|DS)ae 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 + , 0 + ] >>> L = F.quot >>> l = F.lift(e) >>> l [1, 0] + <[x**2 + 1, 0], [0, x**2 + 1]> >>> L.contains(l) True cSg|]}|jqSrr~r.rrrrsBz/FreeModuleQuotientRing.lift..)rrr'rrrlift+szFreeModuleQuotientRing.liftcCs ||jS)a 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 )rrIr'rrrunliftDs zFreeModuleQuotientRing.unliftN) rBrCrDrErr{rrrrrrrrs  rc@seZdZdZddZddZddZdd Zd d Zd1d dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*ZeZd+d,Zd-d.Zd/d0Zd S)2ra 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 csHt|jtfdd|D|_|_j|_j|_j|_dS)Nc3r-r rr.rrrr2wr3z%SubModule.__init__..)r rrrgrrrrrrrrrrrus  zSubModule.__init__cCsdddd|jDdS)N.>)rzrr1rrrr{}szSubModule.__repr__cCr)zVImplementation of containment. Other is guaranteed to be FreeModuleElement.rr!rrr _containszSubModule._containscCr)z9Implementation of syzygy computation wrt self generators.rr1rrr _syzygiesr zSubModule._syzygiescCr)z4Implementation of expression in terms of generators.rr$rrr_in_terms_of_generatorsr z!SubModule._in_terms_of_generatorsNcCsFt||jjr|j|ur|St|j||}||_||s!t|S)aF 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] )rrrrHrrrr )rrrrrrrrs zSubModule.convertcCr)zeImplementation of intersection. Other is guaranteed to be a submodule of same free module.rr!rrr _intersectrzSubModule._intersectcCr)zaImplementation of quotient. Other is guaranteed to be a submodule of same free module.rr!rrr_module_quotientrzSubModule._module_quotientcK@t|ts td||j|jkrtd||j|fi|S)a 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]>, [(DMP_Python([[1, 0]], QQ),)], [(DMP_Python([[1], []], QQ),)]) 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. %s is not a SubModule*%s is contained in a different free module)rr TypeErrorr ValueErrorrrr"optionsrrr intersects   zSubModule.intersectcKr)a 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) 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) (, [[DMP_Python([[1]], QQ)]]) 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. rr)rrrrrrrrrrmodule_quotients !  zSubModule.module_quotientcCsDt|ts td||j|jkrtd|||j|j|jS)a 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]) # >>> N = F.submodule([x**2 - 1]) # <(x-1)(x+1)> >>> M.union(N) == F.submodule([x+1]) True rr)rrrrrrUrr!rrrunions   zSubModule.unioncCstdd|jDS)aF 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 css|]}|dkVqdS)rNrr.rrrr2rlz$SubModule.is_zero..)r5rr1rrrr<szSubModule.is_zerocGs(||s td||f|||jS)a  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]> z%s not a subset of %s)r6rrUrrrrrr s zSubModule.submodulecstfddjDS)e 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 c3r-r r*r.r1rrr2@r3z+SubModule.is_full_module..)r5rrr1rr1ris_full_module1szSubModule.is_full_modulecsRt|trj|jkotfdd|jDSt|ttfr'j|ko&SdS)a 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 c3r-r r*r.r1rrr2Tr3z)SubModule.is_submodule..F)rrrr5rrrrr!rr1rr7Bs  zSubModule.is_submodulec s4|jt|jjfdd|Di|S)a 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 csg|] }|dkr|qSrrr.rrrrsxz+SubModule.syzygy_module..)rrrrrr)rrrrr syzygy_moduleYszSubModule.syzygy_modulecCs8z||}Wntytd||fw||S)a 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]) # doctest: +SKIP [DMP_Python([-1, 1, 0], QQ), DMP_Python([1, 0, 0], QQ)] z%s is not an element of %s)rr rrr$rrrin_terms_of_generators{s   z SubModule.in_terms_of_generatorscCs|S)z 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. r)rr0rrrreduce_elementszSubModule.reduce_elementcKs6||s td||ft|j|j|fi|S)aI 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]>> z%s not a submodule of %s)r7rSubQuotientModulerrr#)rr"rrrrr#s  zSubModule.quotient_modulecCs|j||Sr )rr#r)rothrrrrXszSubModule.__add__csjfdd|jjDS)a< 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]> cs"g|] \}jD]}||qqSr)r)r/r0gr1rrrss"z,SubModule.multiply_ideal..)r_moduler)rIrr1rr=szSubModule.multiply_idealcCs|j|S)a 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]]) )rrArestrict_domainr1rrr inclusion_homszSubModule.inclusion_homcCs|j||S)aA 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]]) )rrArrestrict_codomainr1rrrrAs zSubModule.identity_homr )rBrCrDrErr{rrrrrrrrrr<rrr7rrrr#rXrbr=rrArrrrr^s4 #("  rc@rc)ra 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 cKsFt||||jj|_|jjjdd|jDi||j|_dS)NcSrrr~r.rrrrs rz.SubQuotientModule.__init__..)rrr killed_modulebaserrr)rrrrrrrrs zSubQuotientModule.__init__cCs|j|jSr )rr(rIr'rrrr szSubQuotientModule._containscfddjDS)Ncsg|] }|dtjqSr )rr)r/Xr1rrrsrz/SubQuotientModule._syzygies..)rrr1rr1rrs zSubQuotientModule._syzygiescCs|j|jdt|jSr )rrrIrrr$rrrrsz)SubQuotientModule._in_terms_of_generatorscCr|)r)rrr1rrrrs z SubQuotientModule.is_full_modulecC|j|jS)a 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]]) rrAquotient_codomainrr1rrr quotient_hom0rzSubQuotientModule.quotient_homN) rBrCrDrErrrrrrrrrrrs rcCs|dS)Nrrr0rrrDsrcCs |ddS)NrrrrrrEs c@seZdZdZddZdS) ModuleOrderz>> 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 lexTcCsNt|||t|tstdd|tt||jj||_d|_ d|_ dS)Nz)This implementation is for submodules of zFreeModulePolyRing, got %s) rrrrrrrrorder_gb_gbe)rrrrrrrrrfs  zSubModulePolyRing.__init__cCs&t|tr |j|jkr dSt||Sra)rrrrr8r!rrrr8os zSubModulePolyRing.__eq__Fcsddlm}m}jdur0|r0|fddjD|jjjdd\}}t|t|_ _j durJt|fddjD|jjj_ |rRj jfSj S) z%Returns a standard basis in sdm form.r) sdm_groebner sdm_nf_moraNcg|] }j|jqSrr_vector_to_sdmrr.r1rrrsyz/SubModulePolyRing._groebner..Textendedcrrrr.r1rrrs~r) sympy.polys.distributedmodulesrrrrrrrrgr)rrrrgbgberr1r _groebnerts    zSubModulePolyRing._groebnercsN|s fddDSjdd\}}fdd|Dfdd|DfS)z)Returns a standard basis in element form.c s&g|]}ttj|jqSr)rdrgr_sdm_to_vectorrr.r1rrrss z3SubModulePolyRing._groebner_vec..Trcs"g|] }j|jqSr)rrrrr.r1rrrscs g|] }j|tjqSr)rrrrr.r1rrrs )r)rrrrrr1r _groebner_vecs  zSubModulePolyRing._groebner_veccCs:ddlm}m}||j||j||j|jj|kS)Nr)sdm_zeror)rrrrrrrr)rr0rrrrrrs zSubModulePolyRing._containsc st|j}|j|jd|jd}|j|}g}t|jD]9\}}dg|}t|D] \}} ||||<q2t|D]}||krI|n||<qAt|t |}| |q#|j |ddd} | } fdd| D} | S)z-Compute syzygies. See [SCA, algorithm 2.5.4].rrilexFrrcs6g|]}tfdd|dDr|dqS)c3s|]}|kVqdSr rr/re)zerorrr2rlz9SubModulePolyRing._syzygies...Nr4r.rrrrrss6z/SubModulePolyRing._syzygies..) rrrrrr enumeraterrdrgappendrr) rkoneRkrnewgensjfrPrvrGG0rrrrs$     zSubModulePolyRing._syzygiescsbjjjfj}|jddd}|}fdd|Ddfdddd DS) z4Expression in terms of generators. See [SCA, 2.8.1].rFrcs g|] }j|dr|qSr)ris_unitr.r1rrrsrz=SubModulePolyRing._in_terms_of_generators..rcsg|] }| dqSrrr.)r%rrrsrtrN)rrrrrrr)rr%rSr r)r%rrrsz)SubModulePolyRing._in_terms_of_generatorsNc CsPddlm}|dur |}|j|j||j||j||j|jj |j S)z 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!). r)rN) rrrrrrrrrrr)rr0NFrrrrrs  z SubModulePolyRing.reduce_elementc sj|j}jfddtD}tD]}d|||<d|||<qfddD}fdd|D}jdj|||}fdd|D} jjfdd | D} fd d| D} fd d| D} |r~| | | fS| S) Ncsg|] }dgdqS)rr)r/_rrrrsrtz0SubModulePolyRing._intersect..rcsg|] }t|dgqSrlist)r/r rrrrsrcsg|] }dgt|qSrr)r/hrrrrsrrcs.g|]}tfdd|dDr|qS)c3s|] }|jjkVqdSr rrrr1rrr2rfz:SubModulePolyRing._intersect...N)ryr.)rrrrrss.c3s&|]}dd|dDVqdS)cSg|]}| qSrrrrrrrsrz:SubModulePolyRing._intersect...Nrr.rrrr2s$z/SubModulePolyRing._intersect..cs g|] }|tqSrrr.firrrrsrcs g|] }|tdqSr rr.rrrrsr)rrrrrrrr) rr" relationshicirdieisyznonzeroresreln1reln2r)rrrrrs"  " zSubModulePolyRing._intersectcs|r t|jdkr tt|jdkrjdSt|jdkr~t|jddg}ddjD}jjdj|g|ddd}|sUjjfdd| DS|j d d \fd dt D}jjfd d|Dfd d|DfSt ddfdd|jDS)NrrcSsg|] }t|dgqSrrr.rrrrsrtz6SubModulePolyRing._module_quotient..rFrcs2g|]}tfdd|ddDr|dqS)c3|] }|jjkVqdSr rrr1rrr2rf@SubModulePolyRing._module_quotient...NrYr4r.r1rrrssTrcs2g|]\}}tfdd|ddDr|qS)c3r%r rrr1rrr2rfr&NrYr4)r/rr0r1rrrss  csg|]}|dqS)rYrr)r rrrscs&g|]}dd|ddDqS)cSrrrr.rrrrsrzASubModulePolyRing._module_quotient...rNrr)Rrrrss&cSr)r )r)r0rerrrrs z4SubModulePolyRing._module_quotient..c3s"|] }j|VqdSr )rrrr.r1rrr2rz5SubModulePolyRing._module_quotient..) rrrrr>rrrrrrr)rr"rg1girindicesr)r r(rrrs( z"SubModulePolyRing._module_quotient)rT)Fr )rBrCrDrErr8rrrrrrrrrrrrrRs    ! rc@s0eZdZdZddZddZddZdd Zd S) ra 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 + y + ]> >>> 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 cs2t||jjjfddjD_dS)Ncsg|]}j|qSr)rrr.r1rrrsr'z2SubModuleQuotientRing.__init__..)rrrrrrrrr1rrs zSubModuleQuotientRing.__init__cCs|j|j|Sr )rrrrr'rrrr r9zSubModuleQuotientRing._containscr)Ncs"g|] }tfdd|DqS)c3s"|] }j|jjVqdSr rrrrr1rrr2$rz=SubModuleQuotientRing._syzygies...rmr.r1rrrs$rz3SubModuleQuotientRing._syzygies..)rrr1rr1rr#s zSubModuleQuotientRing._syzygiescs"fddjj|DS)Ncsg|] }j|jjqSrr,r.r1rrrs(rzASubModuleQuotientRing._in_terms_of_generators..)rrrrr'rr1rr's z-SubModuleQuotientRing._in_terms_of_generatorsN)rBrCrDrErrrrrrrrrs  rc@r)QuotientModuleElementzElement of a quotient module.cCs|jj||S)zEquality comparison.)rHrr(rJrrrrT3szQuotientModuleElement.eqcCst|jdt|jjS)Nz + )rrIrHrr1rrrr{7szQuotientModuleElement.__repr__N)rBrCrDrErTr{rrrrr-0s r-c@sVeZdZdZeZddZddZddZdd Z d d Z dd dZ ddZ ddZ d S)ra 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 cCs>t||||std||f||_||_|j|_dS)Nz%s is not a submodule of %s)r rr7rrrr)rrrrrrrrKs   zQuotientModule.__init__cCr)N/)rrrr1rrrr{SrizQuotientModule.__repr__cCs |j|jkS)a 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 )rrr1rrrr<Vs zQuotientModule.is_zerocCs<t|tr|j|jko|j|jSt|tr|j|kSdS)ah 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 F)rrrrr7rrr!rrrr7js     zQuotientModule.is_submodulecOr)ad 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]>> )rrrrrrszQuotientModule.submoduleNcCsRt|tr |j|ur |S|j|jjrt||j|jStt||j|S)a 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]> ) rr-rHrr7rrrIr rrrrrs  zQuotientModule.convertcCs|j|j|jS)av 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]]) )rrArrquotient_domainr1rrrrAs zQuotientModule.identity_homcCr)a 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]]) rr1rrrrs zQuotientModule.quotient_homr )rBrCrDrEr-rrr{r<r7rrrArrrrrr;s   rN)"rEr functoolsrsympy.polys.agca.idealsrsympy.polys.domains.fieldrsympy.polys.orderingsrrsympy.polys.polyclassesrsympy.polys.polyerrorsr sympy.core.basicr sympy.utilities.iterablesr r rGrdrrrrrrrrrrr-rrrrrs<        td)2fW 5*