OtjdZddlmZddlmZddlmZddlmZddlm Z m Z ddl m Z ddl mZdd lmZdd lmZGd d ZGd dZGddeZGddeZGddeZGddeZGddeZGddeZdZdZGdde ZGdd eZGd!d"eZGd#d$eZ Gd%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)iterablecreZdZdZdZddZdZdZdZdZ d Z d Z d Z d Z d ZdZdZdZeZdZdS)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. c||_dSN)ring)selfrs V/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/polys/agca/modules.py__init__zModule.__init__Gs  Nc>t||jst|S)z Convert ``elem`` into internal representation of this module. If ``M`` is not None, it should be a module containing it. ) isinstancedtyper relemMs rconvertzModule.convertJs# $ ++ !  rct)zGenerate a submodule.NotImplementedErrorrgenss r submodulezModule.submoduleT!!rct)zGenerate a quotient module.rrothers rquotient_modulezModule.quotient_moduleXr#rcjt|ts |j|}||Sr)rrr"r'res r __truediv__zModule.__truediv__\s6!V$$ #"A##A&&&rcT ||dS#t$rYdSwxYw)z5Return True if ``elem`` is an element of this module.TF)rr rrs rcontainszModule.containsas@  LL   4   55 s  ''c,||Srr.r-s r __contains__zModule.__contains__is}}T"""rc:tfd|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 c3BK|]}|VdSrr0.0xrs r z Module.subset..{s/334==##333333rallr%s` rsubsetz Module.subsetls(3333U333333rcV||o||Sr) is_submoduler%s r__eq__z Module.__eq__}s)  ''DE,>,>t,D,DDrc||k Srr%s r__ne__z Module.__ne__sEM""rct)z*Returns True if ``self`` is a zero module.rrs ris_zerozModule.is_zeror#rct)z5Returns True if ``other`` is a submodule of ``self``.rr%s rr<zModule.is_submoduler#rct)z; Multiply ``self`` by the ideal ``other``. rr%s rmultiply_idealzModule.multiply_ideals "!rct|ts: |j|}n#tt f$r t cYSwxYw||Sr)rrridealr rNotImplementedrFr)s r__mul__zModule.__mul__so!U## & &IOOA&&"$78 & & &%%%% &""1%%%s2A  A ct)z-Return the identity homomorphism on ``self``.rrBs r identity_homzModule.identity_homr#rr)__name__ __module__ __qualname____doc__rrr"r'r+r.r1r:r=r@rCr<rFrJ__rmul__rLr?rrrr,s4""""""''' ###444"EEE###""""""""" &&&H"""""rrcheZdZdZdZdZdZdZdZdZ e Z dZ d Z d Z d ZeZd Zd ZdZdS) 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 c"||_||_dSr)moduledata)rrUrVs rrzModuleElement.__init__s  rc ||zS)zAdd data ``d1`` and ``d2``.r?rd1d2s raddzModuleElement.adds Bwrc ||zS)z,Multiply module data ``m`` by coefficient d.r?rmds rmulzModuleElement.mul 1u rc ||z S)z*Divide module data ``m`` by coefficient d.r?r]s rdivzModuleElement.divrarc||kS)z4Return true if d1 and d2 represent the same element.r?rXs reqzModuleElement.eqs Rxrc$t||jr|j|jkr3 |j|}n#t$r t cYSwxYw||j||j|jSr)r __class__rUrr rIr[rVroms r__add__zModuleElement.__add__s"dn-- &dk1I1I &[((,,! & & &%%%% &~~dk488DIrw+G+GHHHAAAc ||j||j|jjdS)N)rgrUr`rVrrrBs r__neg__zModuleElement.__neg__sF~~dk488DI{'//33,5,566 6rct||jr|j|jkr3 |j|}n#t$r t cYSwxYw|| Sr)rrgrUrr rIrjrhs r__sub__zModuleElement.__sub__s{"dn-- &dk1I1I &[((,,! & & &%%%% &||RC   rkc.| |Sr)rjrhs r__rsub__zModuleElement.__rsub__sr"""rct||jjjs8 |jj|}n#t $r t cYSwxYw||j||j |Sr) rrUrrrr rIrgr`rVros rrJzModuleElement.__mul__!T[-344 & &K$,,Q//! & & &%%%% &~~dk488DIq+A+ABBBAAAct||jjjs8 |jj|}n#t $r t cYSwxYw||j||j |Sr) rrUrrrr rIrgrcrVrts rr+zModuleElement.__truediv__rvrwct||jr|j|jkr- |j|}n#t$rYdSwxYw||j|jSNF)rrgrUrr rerVrhs rr=zModuleElement.__eq__sz"dn-- dk1I1I [((,,!   uu wwty"'***sA AAc||k Srr?rhs rr@zModuleElement.__ne__s2:~rN)rMrNrOrPrr[r`rcrerj__radd__rnrprrrJrQr+r=r@r?rrrSrSs(IIIH666!!!###CCCHCCC+++rrSc6eZdZdZdZdZdZdZdZdZ dS) FreeModuleElementz1Element of a free module. Data stored as a tuple.cPtdt||DS)Nc3&K|] \}}||zV dSrr?)r5r6ys rr7z(FreeModuleElement.add..s*33tq!QU333333r)tupleziprXs rr[zFreeModuleElement.adds'33s2r{{333333rc:tfd|DS)Nc3"K|] }|zV dSrr?r5r6ps rr7z(FreeModuleElement.mul.. '&&qQU&&&&&&rrrr_rs `rr`zFreeModuleElement.mul &&&&&A&&&&&&rc:tfd|DS)Nc3"K|] }|z V dSrr?rs rr7z(FreeModuleElement.div..rrrrs `rrczFreeModuleElement.div rrcddlmj}td|Drfd|D}ddfd|DzdzS) Nr)sstrc3@K|]}t|tVdSr)rr r5r6s rr7z-FreeModuleElement.__repr__..s,00az!S!!000000rcNg|]!}jj|"Sr?)rUrto_sympyr4s r z.FreeModuleElement.__repr__..s,???QDK$--a00???r[, c3.K|]}|VdSrr?)r5r6rs rr7z-FreeModuleElement.__repr__..s+551ttAww555555r])sympy.printing.strrrVanyjoin)rrVrs` @r__repr__zFreeModuleElement.__repr__s++++++y 004000 0 0 @????$???DTYY5555555555;;rc4|jSr)rV__iter__rBs rrzFreeModuleElement.__iter__sy!!###rc|j|SrrV)ridxs r __getitem__zFreeModuleElement.__getitem__sy~rN) rMrNrOrPr[r`rcrrrr?rrr~r~st;;444''''''<<<$$$rr~cNeZdZdZeZdZdZdZd dZ dZ dZ d Z d Z d ZdS) FreeModulez Abstract base class for free modules. Additional attributes: - rank - rank of the free module Non-implemented methods: - submodule cJt||||_dSr)rrrank)rrrs rrzFreeModule.__init__-s!d### rcZt|jdzt|jzS)N**reprrrrBs rrzFreeModule.__repr__1s"DI%TY77rct|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%s rr<zFreeModule.is_submodule4sX$ eY ' ' +?d* * eZ ( ( G:*FuzTY/F FurNcttrVjurSjjjkrttt fdjDStrJt fdD}t|jkrtt|Stdr1tj dfjzSt)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] c3bK|])}j|jjV*dSr)rrrU)r5r6rrs rr7z%FreeModule.convert..bs:UUa49,,Q 0@AAUUUUUUrc3LK|]}j|VdSr)rrr4s rr7z%FreeModule.convert..ds3;; ))!,,;;;;;;rr) rr~rUrr rrVr lenr rr)rrrtpls`` rrzFreeModule.convertLs d- . . !{d"" {49,,$$$TUUUUU49UUUUUWW W d^^ !;;;;d;;;;;C3xx49$$$$$T3// / dA   !$TDI,=,=a,@,@+B49+LMM M rc|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)rrBs rrCzFreeModule.is_zeroms"yA~rcddlm}|jtfdt jDS)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)eyec3hK|],}|V-dSr)rrow)r5irrs rr7z#FreeModule.basis..s9FFT\\!%%((++FFFFFFr)sympy.matricesrrrrange)rrrs` @rbasiszFreeModule.basissW '&&&&& C NNFFFFFU495E5EFFFFFFrc.t|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)rr"s rr'zFreeModule.quotient_modules$diy999rc`|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]> )r"rrFr%s rrFzFreeModule.multiply_ideals)t~tzz||,;;EBBBrcLddlm}||||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)rrs rrLzFreeModule.identity_homs3 @?????|D$ 555rr)rMrNrOrPr~rrrr<rrCrr'rFrLr?rrrrs   E8880!!!!B&GGG :::(CCC 66666rrceZdZdZdZdZdS)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 cddlm}t|||t ||st dd|zzt |jtst dd|jzzdS)Nr)PolynomialRingBase$This implementation only works over zpolynomial rings, got %szGround domain must be a field, zgot %s)&sympy.polys.domains.old_polynomialringrrrrrdomr)rrrrs rrzFreeModulePolyRing.__init__sMMMMMMD$---$ 233 K%&L(BT(I'JKK K$(E** =%&G(048(;'<== = = =rct||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 )SubModulePolyRingrr!optss rr"zFreeModulePolyRing.submodules"!t44t444rN)rMrNrOrPrr"r?rrrrs<&===55555rrc0eZdZdZdZdZdZdZdZdS)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 c ddlm}t|||t ||st dd|zz|jj|j}||jj |zz |_ dS)Nr) QuotientRingrzquotient rings, got %s) sympy.polys.domains.quotientringrrrrrr free_moduler base_idealquot)rrrrFs rrzFreeModuleQuotientRing.__init__ sAAAAAAD$---$ -- @%&L7$>'?@@ @ IN & &ty 1 1-a/0 rcfdt|jzdzdzt|jzS)N()rrrBs rrzFreeModuleQuotientRing.__repr__s,T$)__$s*T1DOOCCrct||fi|S)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 )SubModuleQuotientRingrs rr"z FreeModuleQuotientRing.submodules"%T4884888rcJ|jd|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 cg|] }|j Sr?rrs rrz/FreeModuleQuotientRing.lift..Bs!7!7!7Q!&!7!7!7r)rrr-s rliftzFreeModuleQuotientRing.lift+s).y  !7!7$!7!7!7888rc6||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 )rrVr-s runliftzFreeModuleQuotientRing.unliftDs&||DI&&&rN) rMrNrOrPrrr"rrr?rrrrsl&111DDD999&9992'''''rrceZdZdZdZdZdZdZdZddZ d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZeZdZdZdZdS)ra 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 ct|jtfd|D|_|_j|_j|_j|_dS)Nc3BK|]}|VdSrr)r5r6rs rr7z%SubModule.__init__..ws1==1)++A..======r)rrrrr!rrrrr!rs `rrzSubModule.__init__uscin---========= "N N _ rcVddd|jDzdzS)N.~s(::1tAww::::::r>)rr!rBs rrzSubModule.__repr__}s/TYY:: ::::::S@@rct)zVImplementation of containment. Other is guaranteed to be FreeModuleElement.rr%s r _containszSubModule._contains "!rct)z9Implementation of syzygy computation wrt self generators.rrBs r _syzygieszSubModule._syzygiesr#rct)z4Implementation of expression in terms of generators.rr)s r_in_terms_of_generatorsz!SubModule._in_terms_of_generatorsr#rNct||jjr |j|ur|St |j||}||_||st|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] )rrrrUrrrr )rrrrs rrzSubModule.convertsq dDN0 1 1 dkT6I6IK ''a00 1 1~~a   ! rct)zeImplementation of intersection. Other is guaranteed to be a submodule of same free module.rr%s r _intersectzSubModule._intersectrrct)zaImplementation of quotient. Other is guaranteed to be a submodule of same free module.rr%s r_module_quotientzSubModule._module_quotientrrc t|tstd|z|j|jkrt d|z|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&optionss r intersectzSubModule.intersectsp8%++ =3e;<< < ?dn , ,>> 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)rrrrrrrs rmodule_quotientzSubModule.module_quotientsrB%++ =3e;<< < ?dn , ,>> 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)rrrrrrgr!r%s runionzSubModule.unionsu%++ =3e;<< < ?dn , ,td|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 c3"K|] }|dkV dS)rNr?rs rr7z$SubModule.is_zero..s&--a16------r)r9r!rBs rrCzSubModule.is_zeros#--49------rc||st|d||||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 not a subset of )r:rrgrr s rr"zSubModule.submodule sH{{4   EddCDD D~~dDN333rchtfdjDS)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 c3BK|]}|VdSrr0r4s rr7z+SubModule.is_full_module..@s/DD4==##DDDDDDr)r9rrrBs`ris_full_modulezSubModule.is_full_module1s6DDDDT^-A-A-C-CDDDDDDrct|tr0j|jkotfd|jDSt|t t frj|koSdS)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 c3BK|]}|VdSrr0r4s rr7z)SubModule.is_submodule..Ts/99DMM!$$999999rF)rrrr9r!rrrr%s` rr<zSubModule.is_submoduleBs eY ' ' :>U_4:9999ej99999 : ej.9 : : E>U*Dt/B/B/D/D Durc |jt|jjfd|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 cFg|]}|dk|Srr)r5r6rs rrz+SubModule.syzygy_module..xs-NNN1AIIaLLA>> 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 is not an element of )rr rrr)s rin_terms_of_generatorsz SubModule.in_terms_of_generators{se G QAA G G GQQQEFF F G++A...s7c|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?)rr6s rreduce_elementzSubModule.reduce_elements rc ||st|d|t|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 not a submodule of )r<rSubQuotientModuler!rr')rr&rs rr'zSubModule.quotient_modulesj.  '' I555$$GHH H ..u55??9=?? ?rc\|j||Sr)rr'r)roths rrjzSubModule.__add__s&~--d33;;C@@@rcDjfd|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]> c2g|]\}jD]}||zSr?)r!)r5r6grs rrz,SubModule.multiply_ideal..s.QQQtyQQ!!QQQQr)r"_moduler!)rIs` rrFzSubModule.multiply_ideals-t~QQQQqy~QQQRRrcZ|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]]) )rrLrestrict_domainrBs r inclusion_homzSubModule.inclusion_homs& ~**,,<>> 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]]) )rrLrrestrict_codomainrBs rrLzSubModule.identity_homs;~**,,<< ##D)) *rr)rMrNrOrPrrrrrrrrrrrrCr"rr<rrrr'rjr|rFrrLr?rrrr^s,%%%AAA""" """""".""" """ !1!1!1F&7&7&7PFFF,..."444"EEE". # # #D///(???8AAAHSSS CCC$*****rrc6eZdZdZdZdZdZdZdZdZ dS) 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 c t||||jj|_|jjjd|jDi||j|_dS)Ncg|] }|j Sr?rrs rrz.SubQuotientModule.__init__.. s ( ( (af ( ( (r)rrr killed_modulebaser"r!r)rr!rrs rrzSubQuotientModule.__init__sv4y111!^92DN'1 ( (di ( ( (2,02227%8J2K2K rc@|j|jSr)r%r.rVr-s rrzSubQuotientModule._contains sy!!$),,,rcNfdjDS)NcHg|]}|dtjSr)rr!)r5Xrs rrz/SubQuotientModule._syzygies..s*BBBq/3ty>>/"BBBr)r%rrBs`rrzSubQuotientModule._syzygiess.CBBBDI,?,?,A,ABBBBrct|j|jdt|jSr)r%rrVrr!r)s rrz)SubQuotientModule._in_terms_of_generatorss+y0088#di..IIrc4|jS)r)r%rrBs rrz SubQuotientModule.is_full_modulesy'')))rcd|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]]) r%rLquotient_codomainr$rBs r quotient_homzSubQuotientModule.quotient_hom0s)"y%%''99$:LMMMrN) rMrNrOrPrrrrrr/r?rrrrs*LLL--- C C CJJJ***"NNNNNrrc|dS)Nrr?r6s rr2Ds 1Q4rc|ddS)Nr?r1s rr2r2Es1QRR5rceZdZdZdZdS) 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 lexTct|||t|tst dd|zzt t ||jj||_d|_ d|_ dS)Nz)This implementation is for submodules of zFreeModulePolyRing, got %s) rrrrrr6rrorder_gb_gbe)rr!rr@r<s rrzSubModulePolyRing.__init__fs4y111)%788 I%&Q;iG'HII I e!4!4diosKK  rct|tr|j|jkrdSt||Srz)rrr@rr=r%s rr=zSubModulePolyRing.__eq__os> e. / / DJ%+4M4M5e,,,rFcddlm}m}j^|r\|fdjD|jjjd\}}t|t|c_ _j @t|fdjD|jjj_ |rj jfSj S)z%Returns a standard basis in sdm form.r) sdm_groebner sdm_nf_moraNcPg|]"}j|j#Sr?r_vector_to_sdmr@r4s rrz/SubModulePolyRing._groebner..ys-LLLQ))!TZ88LLLrTextendedcPg|]"}j|j#Sr?rHr4s rrz/SubModulePolyRing._groebner..~s-YYY!di66q$*EEYYYr) sympy.polys.distributedmodulesrErFrBr!r@rrrrA)rrKrErFgbgbes` r _groebnerzSubModulePolyRing._groebnertsLLLLLLLL 9  "lLLLL$)LLLTZGGGGB#())U3ZZ DHdi 8 \\YYYYtyYYYDJ 7788DH  8TY& &8Orc|s fdDSd\}}fd|Dfd|DfS)z)Returns a standard basis in element form.c g|]=}ttj|j>Sr?)r~rr_sdm_to_vectorrr4s rrz3SubModulePolyRing._groebner_vec..sV///&ddi66q$)DDEEGG///rTrJcvg|]5}j|j6Sr?)rrrSrr4s rrz3SubModulePolyRing._groebner_vec..sIdi66q$)DDEErcjg|]/}j|tj0Sr?)rrSrr!r4s rrz3SubModulePolyRing._groebner_vec..s3JJJ))!S^^<<JJJr)rP)rrKrNrOs` r _groebner_veczSubModulePolyRing._groebner_vecs /////!^^--/// /..$.//CJJJJcJJJL Lrcddlm}m}||j||j||j|jj|kS)Nr)sdm_zerorF)rMrXrFrrIr@rPr)rr6rXrFs rrzSubModulePolyRing._containsskHHHHHHHH{4933AtzBB>>++TZHH HJJ rcj t|j}|j |jd|jd}|j |z}g}t |jD]|\}}dg |zz}t |D] \}} | ||< t|D]}||kr|n| |z<t|t|}| |}|j |ddd} | } fd| D} | S)z-Compute syzygies. See [SCA, algorithm 2.5.4].rr4ilexFr@r<cjg|]/}tfd|dD%|d0S)c3$K|] }|kV dSrr?)r5rzeros rr7z9SubModulePolyRing._syzygies...s'%?%?Aa4i%?%?%?%?%?%?rNr8)r5r6rr^s rrz/SubModulePolyRing._syzygies..sK @ @ @#%?%?%?%?2A2%?%?%?"?"? @ae @ @ @r) rr!rrrr enumeraterr~rappendr"rV)rkoneRkrnewgensjfr^rvrGG0rr^s @@rrzSubModulePolyRing._syzygiess]  NN Iy  ##i""i##AE**di((  DAqQU A!!   1!1XX 3 3"#q&&33d!a%!#uQxx00A NN1     CM7&e < < < OO  A @ @ @ @Q @ @ @ rcjjjfjz}|dd}|}fd|DdfdddDS) z4Expression in terms of generators. See [SCA, 2.8.1].rZFr[cTg|]$}j|d"|%Sr )ris_unitr4s rrz=SubModulePolyRing._in_terms_of_generators..s2 5 5 51TY..qt44 5Q 5 5 5rrc(g|]}| dz Sr r?)r5r6r*s rrz=SubModulePolyRing._in_terms_of_generators..s#'''A1Q4'''rr4N)rrrr"r!rrV)rr*rSrhs`` rrz)SubModulePolyRing._in_terms_of_generatorss 7DI ! !$) , , 6! 9I K OOe  % % OO   5 5 5 5 5 5 5a 8''''122''''rNc ddlm}||}|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)rF) rMrFrrrrSrIr@rPrr)rr6NFrFs rrz SubModulePolyRing.reduce_elements ?>>>>> :B~%%di&>&>rr I $ $Q 3 3T^^5E5E J @'@' I'' rc j |j}jfdtD}tD]}d|||<d|||z<fd D}fd|D}jdzj||z|z}fd|D} jjfd| D} fd| D} fd | D} |r| | | fS| S) Nc"g|] }dgdzz S)rr?)r5_rs rrz0SubModulePolyRing._intersect..s# * * *Aqc1Q3i * * *rr4c<g|]}t|dgzzSr list)r5rfrs rrz0SubModulePolyRing._intersect..s) * * *!d1ggAo * * *rc<g|]}dgzt|zSr rv)r5hrs rrz0SubModulePolyRing._intersect..s) * * *!qc!ed1ggo * * *rrscZg|]'}tfd|dD%|(S)c38K|]}|jjkVdSrrr^r5rrs rr7z:SubModulePolyRing._intersect...s,(L(Ldin)<(L(L(L(L(L(LrN)r)r5r6rrs rrz0SubModulePolyRing._intersect..sCMMMS(L(L(L(Lae(L(L(L%L%LM1MMMrc3@K|]}d|dDVdS)cg|]}| Sr?r?)r5rs rrz:SubModulePolyRing._intersect...s)<)<)<1")<)<).s:(N(N)<).s,333a1QR[=!333rcDg|]}|tzdSrrrs rrz0SubModulePolyRing._intersect..s+222Q1s2ww;<<222r)r!rrrrr"rr)rr& relationshiciradieisyznonzeroresreln1reln2rrs` @@rrzSubModulePolyRing._intersectsk Y Z I * * * *q * * *q  ABqE!HBqE!a%LL * * * *r * * * * * * *r * * *2di##AaC((2R"Wr\CMMOOMMMMMcMMM&dn&(N(N(N(Ng(N(N(NO33333733322222'222  %u$ $ rc|rt|jdkrtt|jdkrjdSt|jdkrt |jddgz}djD}jjdzj|g|zddd}|s-jjfd| DS| d \fd tD}jjfd |Dfd |DfStd fd|jDS)Nr4rc4g|]}t|dgzSr rvrs rrz6SubModulePolyRing._module_quotient..s$333A$q''QC-333rrZFr[cfg|]-}tfd|ddD%|d.S)c38K|]}|jjkVdSrr|r}s rr7z@SubModulePolyRing._module_quotient...s,,Q,QQQ$).-@,Q,Q,Q,Q,Q,QrNrmr8r4s rrz6SubModulePolyRing._module_quotient..s])S)S)S1),,Q,Q,Q,Q!CRC&,Q,Q,Q)Q)Q)S2)S)S)SrTrJc`g|]*\}}tfd|ddD(|+S)c38K|]}|jjkVdSrr|r}s rr7z@SubModulePolyRing._module_quotient...s,CCqqDIN2CCCCCCrNrmr8)r5rr6rs rrz6SubModulePolyRing._module_quotient..s]EEEACCCCAcrcFCCCCCE1EEErc,g|]}|dS)rmr?)r5rrhs rrz6SubModulePolyRing._module_quotient..s!)D)D)Dq!A$r()D)D)DrcDg|]}d|ddDS)cg|]}| Sr?r?rs rrzASubModulePolyRing._module_quotient...s///1"///rr4Nr?)r5rRs rrz6SubModulePolyRing._module_quotient..s4AAAA//ad122h///AAArc,||Sr)r)r6rs rr2z4SubModulePolyRing._module_quotient..s1;;q>>rc3rK|]1}j|V2dSr)rrr"r4s rr7z5SubModulePolyRing._module_quotient..sA T TAT " "4>#;#;A#>#> ? ? T T T T T Tr) rr!rrrHrwrrr"rVr_r) rr&rg1girindicesrhrs ` @@rrz"SubModulePolyRing._module_quotients  &UZA--% % uz??a  9??1%% % __ ! ! ejm$$s*B33333B> %%di!m44>"28eEEEA C&ty)S)S)S)S8I8I)S)S)STT551EEEE1EEE' )D)D)D)DG)D)D)DEAAAAAAACC 11 T T T T T T TVV Vr)r>T)Fr)rMrNrOrPrr=rPrVrrrrrrr?rrrrRs&--- " L L L L B ( ( (    (VVVVVVrrc*eZdZdZdZdZdZdZdS)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 ct||jjjfdjD_dS)NcDg|]}j|Sr?)rrr4s rrz2SubModuleQuotientRing.__init__..s) 8 8 8dn!!!$$ 8 8 8r)rrrrr"r!rs` rrzSubModuleQuotientRing.__init__sN4y1111DN'1 8 8 8 8di 8 8 8: rcf|j|j|Sr)rrrrr-s rrzSubModuleQuotientRing._contains s(y""4>#6#6t#<#<===rcNfdjDS)NcFg|]}tfd|DS)c3bK|])}j|jjV*dSrrrrr}s rr7z=SubModuleQuotientRing._syzygies...$s9FFqdi''49>::FFFFFFrrr4s rrz3SubModuleQuotientRing._syzygies..$sF000FFFFAFFFFF000r)rrrBs`rrzSubModuleQuotientRing._syzygies#s<0000,,..000 0rcfdjj|DS)NcZg|]'}j|jj(Sr?rr4s rrzASubModuleQuotientRing._in_terms_of_generators..(sAJJJ !!!TY^44JJJr)rrrrr-s` rrz-SubModuleQuotientRing._in_terms_of_generators'sVJJJJ I - -dn.A.A$.G.G H HJJJ JrN)rMrNrOrPrrrrr?rrrrs_(::: >>>000JJJJJrrceZdZdZdZdZdS)QuotientModuleElementzElement of a quotient module.cF|jj||z S)zEquality comparison.)rUr$r.rXs rrezQuotientModuleElement.eq3s{(11"r':::rcdt|jdzt|jjzS)Nz + )rrVrUr$rBs rrzQuotientModuleElement.__repr__7s'DI&dk.G)H)HHHrN)rMrNrOrPrerr?rrrr0s='';;;IIIIIrrcHeZdZdZeZdZdZdZdZ dZ d dZ d Z d Z dS) 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 ct||||st|d|||_||_|j|_dS)Nz is not a submodule of )rrr<rr%r$r)rrr%r"s rrzQuotientModule.__init__Ksbd###  ++ PiiiNOO O &I rcZt|jdzt|jzS)N/)rr%r$rBs rrzQuotientModule.__repr__Ss%DI$tD,>'?'???rc"|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 )r%r$rBs rrCzQuotientModule.is_zeroVs$yD...rct|tr/|j|jko|j|jSt|t r |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)rrr$r%r<rrr%s rr<zQuotientModule.is_submodulejsh e^ , , 3%)<<3 &&uz22 3 e. / / +?d* *urct||fi|S)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]>> )rrs rr"zQuotientModule.submodules !t44t444rNcBt|trc|j|ur|S|j|jjr-t||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]> ) rrrUr$r<r%rrVr rs rrzQuotientModule.converts d1 2 2 !{d"" !..t{/HII Q,T493D3DTY3O3OPPP $T49+<+>> 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]]) )r%rLr.r$quotient_domainrBs rrLzQuotientModule.identity_homsAy%%''99    /0B C C Drcd|j|jS)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]]) r-rBs rr/zQuotientModule.quotient_homs0$y%%''99     rr)rMrNrOrPrrrrrCr<r"rrLr/r?rrrr;s   "E@@@///(.555$DDDD0DDD$     rrN)"rPr functoolsrsympy.polys.agca.idealsrsympy.polys.domains.fieldrsympy.polys.orderingsrrsympy.polys.polyclassesr sympy.polys.polyerrorsr sympy.core.basicr sympy.utilities.iterablesr rrSr~rrrrrr9r8r6rrrrr?rrrsd())))))++++++<<<<<<<<''''''111111%%%%%%......q"q"q"q"q"q"q"q"h]]]]]]]]H 4e6e6e6e6e6e6e6e6P/5/5/5/5/5/5/5/5d_'_'_'_'_'Z_'_'_'LL*L*L*L*L*L*L*L*^ TNTNTNTNTN TNTNTNn  DDDDD,DDDqVqVqVqVqV qVqVqVh#J#J#J#J#JI#J#J#JTIIIIIMIIIU U U U U VU U U U U r