\h@PSrSSKJr SSKJrJrJrJrJrJ r SSK J r SSK J r SSKJr SSKJr SSKJr SS KJrJr SS KJrJr SS KJr SS KJr SS KJ r SSK!J"r"J#r#J$r$ SSK%J&r& SSK'J(r( SSK)J*r* SSK+J,r, SSK-J.r. SSK/J0r0J1r1 SSK2J3r3J4r4J5r5J6r6 SSK7J&r8J9r:J;r; SSKr>J?r? SSK@JArA SSKBJCrCJDrD SSKEJFrF SSKGJHrH \C\04S&Sjj5rI\C\04Sj5rJ\C\04Sj5rK\CS5rLS rM"S!S"\A\5rN"S#S$\(\A\\O5rPg%)'zSparse polynomial rings. ) annotations)addmulltlegtge)reduce) GeneratorType)cacheit)Expr)igcd)Symbolsymbols) CantSympifysympify)multinomial_coefficients)IPolys)construct_domain)ninf dmp_to_dict dmp_from_dict)Domain) DomainElementPolynomialRingheugcd) MonomialOps)lex MonomialOrder)CoercionFailedGeneratorsErrorExactQuotientFailedMultivariatePolynomialError)rOrder build_options)expr_from_dict _dict_reorder_parallel_dict_from_expr)DefaultPrinting)publicsubsets) is_sequence)pollutec:[XU5nU4UR-$)aRConstruct a polynomial ring returning ``(ring, x_1, ..., x_n)``. Parameters ========== symbols : str Symbol/Expr or sequence of str, Symbol/Expr (non-empty) domain : :class:`~.Domain` or coercible order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex`` Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex >>> R, x, y, z = ring("x,y,z", ZZ, lex) >>> R Polynomial ring in x, y, z over ZZ with lex order >>> x + y + z x + y + z >>> type(_) PolyRinggensrdomainorder_rings I/var/www/auris/envauris/lib/python3.13/site-packages/sympy/polys/rings.pyringr9$s!8 We ,E 8ejj  c4[XU5nX3R4$)aXConstruct a polynomial ring returning ``(ring, (x_1, ..., x_n))``. Parameters ========== symbols : str Symbol/Expr or sequence of str, Symbol/Expr (non-empty) domain : :class:`~.Domain` or coercible order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex`` Examples ======== >>> from sympy.polys.rings import xring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex >>> R, (x, y, z) = xring("x,y,z", ZZ, lex) >>> R Polynomial ring in x, y, z over ZZ with lex order >>> x + y + z x + y + z >>> type(_) r1r4s r8xringr<Cs8 We ,E :: r:c[XU5n[URVs/sHoDRPM snUR5 U$s snf)a\Construct a polynomial ring and inject ``x_1, ..., x_n`` into the global namespace. Parameters ========== symbols : str Symbol/Expr or sequence of str, Symbol/Expr (non-empty) domain : :class:`~.Domain` or coercible order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex`` Examples ======== >>> from sympy.polys.rings import vring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex >>> vring("x,y,z", ZZ, lex) Polynomial ring in x, y, z over ZZ with lex order >>> x + y + z # noqa: x + y + z >>> type(_) )r2r/rnamer3)rr5r6r7syms r8vringr@bs=6 We ,E %-- 1-3hh- 15::> L 2sA c Sn[U5(dU/Sp0[[[U55n[ X5n[ X5upTUR c[UVs/sHn[UR55PM sn/5n[XtS9uUln[[Xx55n UVV V s/sH*ofR5V V s0sH upXU _M sn n PM, nn nn [URUR UR5n [[U R U55n U(aXS4$X4$s snfs sn n fs sn n nf)a Construct a ring deriving generators and domain from options and input expressions. Parameters ========== exprs : :class:`~.Expr` or sequence of :class:`~.Expr` (sympifiable) symbols : sequence of :class:`~.Symbol`/:class:`~.Expr` options : keyword arguments understood by :class:`~.Options` Examples ======== >>> from sympy import sring, symbols >>> x, y, z = symbols("x,y,z") >>> R, f = sring(x + 2*y + 3*z) >>> R Polynomial ring in x, y, z over ZZ with lex order >>> f x + 2*y + 3*z >>> type(_) FT)optr)r.listmaprr'r*r5sumvaluesrdictzipitemsr2r3r6 from_dict)exprsroptionssinglerBrepsrepcoeffs coeffs_dom coeff_mapmcr7polyss r8sringrVs4F u  v We$ %E  )C)4ID zzT;TctCJJL)T;R@!1&!B JV01 EIJTcYY[9[TQaL[9TJ SXXszz399 5E U__d+ ,E Qx  ~< :Js#E4E EEEc.[U[5(aU(a [USS9$S$[U[5(aU4$[ U5(a;[ SU55(a [U5$[ SU55(aU$[ S5e)NT)seqc3B# UHn[U[5v M g7fN) isinstancestr.0ss r8 !_parse_symbols..s37az!S!!7c3B# UHn[U[5v M g7fr[)r\r r^s r8rarbs6gAt$$grczbexpected a string, Symbol or expression or a non-empty sequence of strings, Symbols or expressions)r\r]_symbolsr r.allr#rs r8_parse_symbolsrhs'3.5xT*=2= GT " "z W   373 3 3G$ $ 6g6 6 6N ~ r:cp\rSrSr%SrS\S'S\S'S\S'S \S 'S \S '\4S jrSrSr Sr Sr Sr Sr S3Sjr\S5rSr\S5r\S5rSrS4SjrSrSrSr\rS4SjrS4S jrS!rS"rS#rS$r S%r!S&r"S'r#S(r$S)r%\S*5r&\S+5r'S,r(S-r)S.r*S/r+S0r,S1r-S2r.g)5r2z*Multivariate distributed polynomial ring. ztuple[PolyElement, ...]r3ztuple[Expr, ...]rintngensrr5r!r6cl^[[U55n[U5n[R"U5n[ R"T5mUR XUT4nUR(a1[U5[UR5-(a [S5e[RU5nXVl [U5UlXl XFlX&lTUl['US5R(UlSU-UlUR/5Ul[UR05UlUR,UR44/UlU(a[9U5nUR;5UlUR?5Ul URC5Ul"URG5Ul$URK5Ul&URO5Ul(URS5Ul*O/SnXlXl SUl"Xl$Xl&Xl(Xl*T[VLa [XUl-O U4SjUl-[]URUR05HFup[_U [`5(dMU Rbn [eXk5(aM:[gXkU 5 MH U$)Nz7polynomial ring and it's ground domain share generatorsrYrcgNrYrY)abs r8"PolyRing.__new__..s2r:cgrprY)rqrrrTs r8rsrts"r:c>[UTS9$)Nkey)max)fr6s r8rsrts QE):r:)4tuplerhlen DomainOpt preprocessOrderOpt__name__ is_Compositesetrr#object__new__ _hash_tuplehash_hashrlr5r6 PolyElementnewdtype zero_monom_gensr3 _gens_setone_onerr monomial_mulpow monomial_powmulpowmonomial_mulpowldiv monomial_ldivdiv monomial_divlcm monomial_lcmgcd monomial_gcdr ry leading_expvrHr\rr>hasattrsetattr) clsrr5r6rlrobjcodegenmonunitsymbol generatorr>s ` r8rPolyRing.__new__sw/0G %%f-##E*||WVUC   3w<#fnn2E#E!"[\ \nnS!%%     R(,, e99;CHH  ^^VZZ01 !%(G&{{}C &{{}C ").."2C  ' C &{{}C &{{}C &{{}C %G& & "4C  ' & & &  C<"C :C !$S[[#((!; F&&)){{s))Cy1 "< r:cURRn/n[UR5H5nUR U5nUR nXU'UR U5 M7 [U5$)z(Return a list of polynomial generators. )r5rrangerlmonomial_basiszeroappendr{)selfrriexpvpolys r8rPolyRing._gens s_kkootzz"A&&q)D99DJ LL  # U|r:cHURURUR4$r[)rr5r6rs r8__getnewargs__PolyRing.__getnewargs__s dkk4::66r:cURR5nUS UHnURS5(dMX M U$)Nr monomial_)__dict__copy startswith)rstaterxs r8 __getstate__PolyRing.__getstate__sA ""$ . !C~~k**J r:cUR$r[)rrs r8__hash__PolyRing.__hash__#s zzr:c[U[5=(a] URURURUR 4URURURUR 4:H$r[)r\r2rr5rlr6rothers r8__eq__PolyRing.__eq__&sV%*D \\4;; DJJ ? ]]ELL%++u{{ C D Dr:c X:X+$r[rYrs r8__ne__PolyRing.__ne__+s   r:NclUb [U[5(a [U5nURXU5$r[)r\rCr{_clonerrr5r6s r8clonePolyRing.clone.s.  :gt#<#<GnG{{7E22r:cURU=(d URU=(d URU=(d UR5$r[) __class__rr5r6rs r8rPolyRing._clone4s3~~g5v7LeNaW[WaWabbr:c@S/UR-nSX!'[U5$)zReturn the ith-basis element. r)rlr{)rrbasiss r8rPolyRing.monomial_basis8s"DJJU|r:c$UR/5$r[)rrs r8r PolyRing.zero>szz"~r:c8URUR5$r[)rrrs r8r PolyRing.oneBszz$))$$r:cN[U[5=(a URU:H$)zATrue if ``element`` is an element of this ring. False otherwise. )r\rr9relements r8 is_elementPolyRing.is_elementFs';/HGLLD4HHr:c8URRX5$r[)r5convertrr orig_domains r8 domain_newPolyRing.domain_newJs{{""788r:c:URURU5$r[)term_newr)rcoeffs r8 ground_newPolyRing.ground_newMs}}T__e44r:cVURU5nURnU(aX#U'U$r[)rr)rmonomrrs r8rPolyRing.term_newPs(&yy K r:c[U[5(apXR:XaU$[UR[5(a5URRUR:XaUR U5$[ S5e[U[5(a [ S5e[U[5(aURU5$[U[5(aURU5$[U[5(aURU5$UR U5$![a URU5s$f=f)N conversionparsing)r\rr9r5rrNotImplementedErrorr]rGrJrC from_terms ValueError from_listr from_exprrs r8ring_newPolyRing.ring_newWs g{ + +||#DKK88T[[=M=MQXQ]Q]=]w//),77  % %%i0 0  & &>>'* *  & & /w// & &>>'* *??7+ +  /~~g.. /s"D**EEcURnURnUR5HupVU"Xb5nU(dMXdU'M U$r[)rrrI)rrrrrrrs r8rJPolyRing.from_dictosC__ yy#MMOLEu2Eu#U ,  r:c8UR[U5U5$r[)rJrGrs r8rPolyRing.from_termszs~~d7m[99r:cfUR[XRS- UR55$Nr)rJrrlr5rs r8rPolyRing.from_list}s$~~k'::a<MNNr:cV^^^^TRmUUUU4SjmT"[U55$)Nc >TRU5nUbU$UR(a-[[[ [ TUR 555$UR(a-[[[ [ TUR 555$UR5up#UR(aUS:aT"U5[U5-$TRTRU55$r)getis_Addr rrCrDargsis_Mulr as_base_exp is_Integerrkrr)exprrbaseexp_rebuildr5mappingrs r8r(PolyRing._rebuild_expr.._rebuilds D)I$  c4Hdii(@#ABBc4Hdii(@#ABB!,,. >>cAg#D>3s833??6>>$+?@@r:)r5r)rrrrr5s` `@@r8 _rebuild_exprPolyRing._rebuild_exprs) A A$ &&r:c[[[URUR555nUR X5nUR U5$![a [SU<SU<35ef=f)Nz6expected an expression convertible to a polynomial in z, got ) rGrCrHrr3r rr"r)rrrrs r8rPolyRing.from_exprsktC dii89: '%%d4D==& & pcgimno o ps AA4cNUcUR(aSnU$SnU$[U[5(aGUnSU::aX R:aU$UR*U::aUS::aU*S- nU$[SU-5eUR U5(aUR R U5nU$[U[5(aURR U5nU$[SU-5e![a [SU-5ef=f![a [SU-5ef=f)z+Compute index of ``gen`` in ``self.gens``. rrzinvalid generator index: %szinvalid generator: %szEexpected a polynomial generator, an integer, a string or None, got %s) rlr\rkrrr3indexr]r)rgenrs r8rPolyRing.indexsI ;zz2/.-S ! !AAv!jj.$#**!a2gBF !!>!DEE __S ! ! @IIOOC(S ! ! @LL&&s+ dgjjk k @ !83!>?? @  @ !83!>?? @sC/D /D D$c[[URU55n[UR5VVs/sHup4X2;dM UPM nnnU(d UR $UR US9$s snnf)z,Remove specified generators from this ring. rg)rrDr enumeraterr5r)rr3indicesrr`rs r8drop PolyRing.dropsac$**d+,"+DLL"9O"9$!Q=MA"9O;; ::g:. . Ps A2A2cdURUnU(d UR$URUS9$)Nrg)rr5r)rrxrs r8 __getitem__PolyRing.__getitem__s.,,s#;; ::g:. .r:cURR(d[URS5(a#URURRS9$[ SUR-5e)Nr5r5z%s is not a composite domain)r5rrrrrs r8 to_groundPolyRing.to_groundsO ;; # #wt{{H'E'E::T[[%7%7:8 8;dkkIJ Jr:c[U5$r[rrs r8 to_domainPolyRing.to_domains d##r:c^SSKJn U"URURUR5$)Nr) FracField)sympy.polys.fieldsr#rr5r6)rr#s r8to_fieldPolyRing.to_fields 0t{{DJJ??r:c2[UR5S:H$rr|r3rs r8 is_univariatePolyRing.is_univariates499~""r:c2[UR5S:$rr(rs r8is_multivariatePolyRing.is_multivariates499~!!r:cURnUH-n[U[S9(aX R"U6- nM)X#- nM/ U$)a Add a sequence of polynomials or containers of polynomials. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> R, x = ring("x", ZZ) >>> R.add([ x**2 + 2*i + 3 for i in range(4) ]) 4*x**2 + 24 >>> _.factor_list() (4, [(x**2 + 6, 1)]) include)rr.r rrobjsprs r8r PolyRing.adds?" IIC3 6XXs^#  r:cURnUH-n[U[S9(aX R"U6-nM)X#-nM/ U$)ap Multiply a sequence of polynomials or containers of polynomials. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> R, x = ring("x", ZZ) >>> R.mul([ x**2 + 2*i + 3 for i in range(4) ]) x**8 + 24*x**6 + 206*x**4 + 744*x**2 + 945 >>> _.factor_list() (1, [(x**2 + 3, 1), (x**2 + 5, 1), (x**2 + 7, 1), (x**2 + 9, 1)]) r/)rr.r rr1s r8r PolyRing.muls?" HHC3 6XXs^#  r:cb[[URU55n[UR5VVs/sHup4X2;dM UPM nnn[UR 5VVs/sHup6X2;dM UPM nnnU(dU$UR XPR"U6S9$s snnfs snnf)zL Remove specified generators from the ring and inject them into its domain. rr5)rrDrrrr3rr)rr3rrr`rrs r8drop_to_groundPolyRing.drop_to_grounds c$**d+,!*4<D::d4j:1 1Kr:c[UR5R[U55nUR[ U5S9$)z9Add the elements of ``symbols`` as generators to ``self``rgr<)rrr>s r8add_gensPolyRing.add_gens4s44<< &&s7|4zz$t*z--r:c^US:dXR:a[SU<SUR<35eU(d UR$URn[ [ UR5[U55HRm[U4Sj[ UR555nX RX0RR5- nMT U$)zW Return the elementary symmetric polynomial of degree *n* over this ring's generators. rz.Cannot generate symmetric polynomial of order z for c3@># UHn[UT;5v M g7fr[)rk)r_rr`s r8ra*PolyRing.symmetric_poly..EsE3Dac!q&kk3D) rlrr3rrr-rrkr{rr5)rnrrr`s @r8symmetric_polyPolyRing.symmetric_poly9s q5A NZ[]a]f]fgh h88O99DU4::.A7E53DEE e[[__==8Kr:rY)NNNr[)/r __module__ __qualname____firstlineno____doc____annotations__r rrrrrrrrr rrpropertyrrrrrrr__call__rJrrr rrrrrr r%r)r,rrr9r?rBrI__static_attributes__rYr:r8r2r2s34 !!  J N ,/<| 7D !3  c c %%I95,,H :O'.'>//K$@##""66 H. r:r2c^\rSrSrSrU4SjrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSSjrSrSrSrSrSrSrSrSrSrSrSrSr Sr!\"S 5r#\"S!5r$\"S"5r%\"S#5r&\"S$5r'\"S%5r(\"S&5r)\"S'5r*\"S(5r+\"S)5r,\"S*5r-\"S+5r.\"S,5r/\"S-5r0\"S.5r1\"S/5r2\"S05r3S1r4S2r5S3r6S4r7S5r8S6r9S7r:S8r;S9rS<r?S=r@S>rAS?rBS@rCSArDSBrESCrFSDrGSErHSFrISGrJSHrKSIrLSJrMSKrNSSLjrOSMrPSSNjrQSOrRSPrSSQrTSRrUSSrV\"ST5rW\"SU5rXSVrY\"SW5rZSXr[SYr\SSZjr]SS[jr^SS\jr_S]r`S^raS_rbS`rcSardSbreScrfSdrgSerhSfriSgrjShrkSirlSjrmSkrnSlro\orpSmrqSnrrSorsSprtSqruSrrvSsrwStrxSurySvrzSwr{Sxr|Syr}Szr~S{rS|rS}rS~rSSjrSSjrSrSSjrSrSSjrSSjrSSjrSSjrSSjrSrSrSrSrSrSrSrSrSrSrSrSrSSjrSrSrU=r$)riJz5Element of multivariate distributed polynomial ring. c0>[TU]U5 Xlgr[)super__init__r9)rr9initrs r8rVPolyElement.__init__Ms  r:c[U[5(de[UR[5(deURRn[U[ 5(deUR 5H[up#URU5(de[U5URR:Xde[SU55(aM[e g)Nc3Z# UH!n[U[5=(a US:v M# g7f)rN)r\rk)r_rs r8ra%PolyElement._check..[s#JESz#s+8q8Es)+) r\rr9r2r5rrIof_typer|rlrf)rdomrrs r8_checkPolyElement._checkSs$ ,,,,$))X....ii#v&&&& JJLLE;;u%% %%u:0 00JEJJJ JJ)r:c:URURU5$r[)rr9)rrWs r8rPolyElement.new]s~~dii..r:c6URR5$r[)r9r rs r8parentPolyElement.parent`syy""$$r:cLUR[UR554$r[)r9rC itertermsrs r8rPolyElement.__getnewargs__cs 4 0122r:NcURnUc5[UR[UR 5545=UlnU$r[)rrr9 frozensetrI)rrs r8rPolyElement.__hash__hs<   =!%tyy)DJJL2I&J!K KDJ r:c$URU5$)aReturn a copy of polynomial self. Polynomials are mutable; if one is interested in preserving a polynomial, and one plans to use inplace operations, one can copy the polynomial. This method makes a shallow copy. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> R, x, y = ring('x, y', ZZ) >>> p = (x + y)**2 >>> p1 = p.copy() >>> p2 = p >>> p[R.zero_monom] = 3 >>> p x**2 + 2*x*y + y**2 + 3 >>> p1 x**2 + 2*x*y + y**2 >>> p2 x**2 + 2*x*y + y**2 + 3 )rrs r8rPolyElement.copyss4xx~r:c tURU:XaU$URRUR:wa^[[[ XRRUR565nUR X RR 5$URXRR 5$r[)r9rrCrHr)rr5rJ)rnew_ringtermss r8set_ringPolyElement.set_rings 99 K YY  ("2"2 2mD))2C2CXEUEUVWXE&&uii.>.>? ?%%dII,<,<= =r:cU(dURRnOS[U5URR:wa0[ SURR<S[U5<35e[ UR 5/UQ76$)Nz"Wrong number of symbols, expected z got )r9rr|rlrr( as_expr_dict)rrs r8as_exprPolyElement.as_exprsfii''G \TYY__ ,#g,0  d//1>;KL;K<5x&;KLLLsA c URRnUR(aUR(dURU4$UR 5nURnUR nURnUR5HnU"X5"U55nM URUR5VVs/sH upxXxU-4PM snn5n X94$s snnfr[) r9r5is_Fieldhas_assoc_Ringrget_ringrdenomrFrrI) rr5 ground_ringcommonrr}rkvrs r8 clear_denomsPolyElement.clear_denomss!!f&;&;::t# #oo' oo [[]Eu.F#xxDJJLBLDA1h-LBC|Cs>C c^[UR55HupU(aMX M g)z+Eliminate monomials with zero coefficient. NrCrI)rrrs r8 strip_zeroPolyElement.strip_zeros#&DA1G'r:cU(dU(+$URRU5(a[RX5$[ U5S:agUR URR 5U:H$)zEquality test for polynomials. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p1 = (x + y)**2 + (x - y)**2 >>> p1 == 4*x*y False >>> p1 == 2*(x**2 + y**2) True rF)r9rrGrr|rrp1p2s r8rPolyElement.__eq__s^"6M WW   # #;;r& & Wq[66"'',,-3 3r:c X:X+$r[rYrs r8rPolyElement.__ne__s |r:cURnURU5(ax[UR55[UR55:wagURR nUR5HnU"XXU5(aM g g[ U5S:agURRU5nURR UR5X5$![a gf=f)z+Approximate equality test for polynomials. FTr) r9rrkeysr5almosteqr|rconstr")rr tolerancer9rrs r8rPolyElement.almosteqsww ??2  2779~RWWY/{{++HWWYrui88  Wq[ G[[((,{{++BHHJFF"  s,C11 C>=C>c8[U5UR54$r[)r|rors r8sort_keyPolyElement.sort_keysD 4::<((r:cURRU5(a%U"UR5UR55$[$r[)r9rrNotImplemented)rrops r8_cmpPolyElement._cmps6 77  b ! !bkkmR[[]3 3! !r:c.URU[5$r[)rrrs r8__lt__PolyElement.__lt__wwr2r:c.URU[5$r[)rrrs r8__le__PolyElement.__le__rr:c.URU[5$r[)rrrs r8__gt__PolyElement.__gt__rr:c.URU[5$r[)rr rs r8__ge__PolyElement.__ge__rr:cURnURU5nURS:Xa X2R4$[ UR 5nXC X2R US94$)Nrrg)r9rrlr5rCrrrrr9rrs r8_dropPolyElement._dropsVyy JJsO ::?kk> !4<<(G jjj11 1r:cjURU5up#URRS:Xa0UR(aUR S5$[ SU-5eUR nUR5H5upVXRS:Xa[U5nXr Xd[U5'M)[ SU-5e U$)NrzCannot drop %sr) rr9rl is_groundrrrrIrCr{)rrrr9rrrKs r8rPolyElement.drops**S/ 99??a ~~zz!}$ !1C!78899D 419QA%&qN$%5%;<< %Kr:cURnURU5n[UR5nXC X2R XBUS94$)Nr8)r9rrCrrrs r8_drop_to_groundPolyElement._drop_to_ground%sCyy JJsOt||$ J**W!W*===r:cURRS:Xa [S5eURU5up#URnUR R SnUR5HQupVUSUXRS-S-nXt;aXU-RU5XG'M1XG==XU-RU5- ss'MS U$)Nrz$Cannot drop only generator to groundr) r9rlrrrr5r3rf mul_ground)rrrr9rrrmons r8r9PolyElement.drop_to_ground-s 99??a CD D&&s+yykkq! NN,LE)eaCDk)C (]66u=  c8m77>> - r:cp[XRRS- URR5$r)rr9rlr5rs r8to_densePolyElement.to_dense>s&T99??1#4dii6F6FGGr:c[U5$r[)rGrs r8to_dictPolyElement.to_dictAs Dzr:c~U(d/URURRR5$USnUSnURnURnUR n UR n /n UR5GHtupURRU 5nU(aSOSnU RU5 X:Xa4URU 5nU(aURS5(aUSSnO@U(aU *n XRRR:waURXSS9nOS n/n[U 5HnU UnU(dMURUUUSS9nUS:waAU[U5:wdUS :aURUUS S9nOUnURUUU4-5 MlURS U-5 M U(aU/U-nU RURU55 GMw U S S ;a)U R!S 5nUS:XaU R#S S5 S RU 5$)NMulAtom -  + -rT)strictrFz%s)rr)_printr9r5rrrlrro is_negativerrr parenthesizerrkjoinpopinsert)rprinter precedence exp_pattern mul_symbolprec_mul prec_atomr9rrlzmsexpvsrrnegativesignscoeffsexpvrrrsexpheads r8r]PolyElement.strDs>>$))"2"2"7"78 8e$v& yy,,  __::LL/"5( MM*//%0 1?(@ !9 &::a=Du} a%wwvr:c2XRR;$r[)r9rrs r8 is_generatorPolyElement.is_generatortsyy****r:czU(+=(d. [U5S:H=(a URRU;$r)r|r9rrs r8rPolyElement.is_groundxs+xLCINKtyy/C/Ct/KLr:cfU(+=(d$ [U5S:H=(a URS:H$r)r|LCrs r8 is_monomialPolyElement.is_monomial|s$x# UHn[U5S:*v M g7frNrEr_rs r8ra(PolyElement.is_linear..?u3u:?rf itermonomsrs r8 is_linearPolyElement.is_linear? ???r:cB[SUR555$)Nc3># UHn[U5S:*v M g7f)Nrrs r8ra+PolyElement.is_quadratic..r r r rs r8 is_quadraticPolyElement.is_quadraticrr:cpURR(dgURRU5$NT)r9rl dmp_sqf_prs r8 is_squarefreePolyElement.is_squarefrees%vv||vv""r:cpURR(dgURRU5$r)r9rldmp_irreducible_prs r8is_irreduciblePolyElement.is_irreducibles%vv||vv''**r:cURR(aURRU5$[S5e)Nzcyclotomic polynomial)r9r)dup_cyclotomic_pr%rs r8 is_cyclotomicPolyElement.is_cyclotomics0 66  66**1- --.EF Fr:czURUR5VVs/sH upX*4PM snn5$s snnfr[)rrf)rrrs r8__neg__PolyElement.__neg__s2xxdnn>NP>Nle5&/>NPQQPs7 cU$r[rYrs r8__pos__PolyElement.__pos__s r:cU(dUR5$URnURU5(agUR5nURnURR nUR 5HupgU"Xe5U-nU(aXsU'MX6 M! U$[U[5(a[UR[5(a%URRUR:XaOd[URR[5(a5URRRU:XaURU5$[$URU5nUR5nU(dU$URn XR5;aXU 'U$XU *:XaX9 U$X9==U- ss'U$![a [s$f=f)zAdd two polynomials. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> (x + y)**2 + (x - y)**2 2*x**2 + 2*y**2 )rr9rrr5rrIr\rr__radd__rrrrr") rrr9r3rrrrcp2rs r8__add__PolyElement.__add__s779 ww ??2   A%%C;;##D L1$aD # H K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% //"%C AB"" H B%<HESLEH "! ! "sG GGcUR5nU(dU$URnURU5nURnX@R 5;aXU'U$XU*:XaX$ U$X$==U- ss'U$![ a [ s$f=fr[)rr9rrrr"r)rrHr3r9rs r8r*PolyElement.__radd__s GGIHww "AB"" H 2;HEQJEH "! ! "sA88B  B cU(dUR5$URnURU5(agUR5nURnURR nUR 5HupgU"Xe5U- nU(aXsU'MX6 M! U$[U[5(a[UR[5(a%URRUR:XaOd[URR[5(a5URRRU:XaURU5$[$URU5nUR5nURnXR5;aU*X8'U$XU:XaX8 U$X8==U-ss'U$![a [s$f=f)zSubtract polynomial p2 from p1. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p1 = x + y**2 >>> p2 = x*y + y**2 >>> p1 - p2 -x*y + x )rr9rrr5rrIr\rr__rsub__rrrrr") rrr9r3rrrrrs r8__sub__PolyElement.__sub__s~ 779 ww ??2   A%%C;;##D L1$aD # H K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% $B AB" H 2;HERKEH "! ! "sGGGcURnURU5nURnUH nX*X4'M X1- nU$![a [s$f=f)zn - p1 with n convertible to the coefficient domain. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p = x + y >>> 4 - p -x - y + 4 )r9rrr"r)rrHr9r3rs r8r1PolyElement.__rsub__Escww "A A8) FAH "! ! "sAAAcURnURnU(aU(dU$URU5(aURnURRnUR n[ UR55nUR5H'upUHupU"X5n U"X5X--X<'M M) UR5 U$[U[5(a[UR[5(a%URRUR:XaOd[URR[5(a5URRRU:XaURU5$[$URU5nUR5HupX-n U (dMXU'M U$![a [s$f=f)zMultiply two polynomials. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', QQ) >>> p1 = x + y >>> p2 = x - y >>> p1*p2 x**2 - y**2 )r9rrrr5rrCrIrr\rr__rmul__rrr")rrr9r3rrrp2itexp1v1exp2v2rrs r8__mul__PolyElement.__mul__asy ww IIH __R %%C;;##D,,L #DHHJ $HD&t2C ^be3AF!%' LLNH K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% $BHHJE1dG' H "! ! "sGG! G!cURRnU(dU$URRU5nUR5Hup4X-nU(dMXRU'M U$![a [ s$f=f)zp2 * p1 with p2 in the coefficient domain of p1. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p = x + y >>> 4 * p 4*x + 4*y )r9rrrIr"r)rrr3r9r:rs r8r7PolyElement.__rmul__sw GGLLH ""2&BHHJE1dG'H "! ! "sA((A;:A;c[U[5(d[SU-5eUS:a[SU-5eURnU(dU(a UR $[S5e[ U5S:Xao[UR55Sup4URnXBRR :XaXEURX15'U$XA-XRRX15'U$[U5nUS:a [S5eUS:XaUR5$US:XaUR5$US:XaXR5-$[ U5S ::aURU5$URU5$) zraise polynomial to power `n` Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p = x + y**2 >>> p**3 x**3 + 3*x**2*y**2 + 3*x*y**4 + y**6 z#exponent must be an integer, got %srz/exponent must be a non-negative integer, got %sz0**0rzNegative exponentr)r\rk TypeErrorrr9rr|rCrIrr5rrsquare_pow_multinomial _pow_generic)rrHr9rrr3s r8__pow__PolyElement.__pow__sT!S!!AAEF F UNQRRS Syyxx (( Y!^ -a0LE A '16$##E-.H27##E-.H F q501 1 !V99;  !V;;= !V % % Y!^((+ +$$Q' 'r:cURRnUnUS-(aX#-nUS-nU(dU$UR5nUS-nM4)Nrr)r9rrE)rrHr3rTs r8rGPolyElement._pow_genericsV IIMM 1uCQ  AQAr:c[[U5U5R5nURRnURR nUR5nURR RnURRnUHpupUn U n [X5H!un upU (dMU"XU 5n XU --n M# [U 5n U nURX5U-nU(aXU 'MgX;dMnX} Mr U$r[) rr|rIr9rrr5rrHr{r)rrH multinomialsrrrorr multinomialmultinomial_coeff product_monom product_coeffrrrs r8rFPolyElement._pow_multinomials/D 1=CCE ))33YY))  yy$$yy~~.: *K&M-M'*;'>#^e3$3M#$NM!CZ/M(? -(E!EHHU)E1E#U K#/;& r:c&URnURnURn[UR 55nUR RnUR n[[U55H;nXGnXn [U5H!n XJn U"X5n U"X5XU --X,'M# M= URS5nURnUR5HupU"X5n U"X5US--X+'M UR5 U$)zsquare of a polynomial Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> p = x + y**2 >>> p.square() x**2 + 2*x*y**2 + y**4 r) r9rrrCrr5rrr|imul_numrIr)rr9r3rrrrrk1pkjk2rrrs r8rEPolyElement.squaresyy IIeeDIIK {{(( s4y!ABB1XW"2*S""X+5" JJqMeeJJLDAa#BMAqD(AE! r:cURnU(d [S5eURU5(aURU5$[ U[ 5(a[ UR [5(a%UR RUR:XaOd[ URR [5(a5URR RU:XaURU5$[$URU5nURU5URU54$![a [s$f=fNpolynomial division)r9ZeroDivisionErrorrrr\rr5r __rdivmod__rr quo_ground rem_groundr"rrr9s r8 __divmod__PolyElement.__divmod__:sww#$9: : __R 66":  K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[~~b))%% :$BMM"%r}}R'89 9 "! ! "sD77E  E cURnURU5nURU5$![a [s$f=fr[)r9rrr"rras r8r^PolyElement.__rdivmod__PEww $B66":  "! ! "0AAcxURnU(d [S5eURU5(aURU5$[ U[ 5(a[ UR [5(a%UR RUR:XaOd[ URR [5(a5URR RU:XaURU5$[$URU5nURU5$![a [s$f=fr[) r9r]rremr\rr5r__rmod__rrr`r"ras r8__mod__PolyElement.__mod__Ysww#$9: : __R 66":  K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% %$B==$ $ "! ! "D&&D98D9cURnURU5nURU5$![a [s$f=fr[)r9rrir"rras r8rjPolyElement.__rmod__orfrgcxURnU(d [S5eURU5(aURU5$[ U[ 5(a[ UR [5(a%UR RUR:XaOd[ URR [5(a5URR RU:XaURU5$[$URU5nURU5$![a [s$f=fr[) r9r]rquor\rr5r __rtruediv__rrr_r"ras r8 __floordiv__PolyElement.__floordiv__xsww#$9: : __R 66":  K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[r**%% %$B==$ $ "! ! "rmcURnURU5nURU5$![a [s$f=fr[)r9rrqr"rras r8 __rfloordiv__PolyElement.__rfloordiv__rfrgcxURnU(d [S5eURU5(aURU5$[ U[ 5(a[ UR [5(a%UR RUR:XaOd[ URR [5(a5URR RU:XaURU5$[$URU5nURU5$![a [s$f=fr[) r9r]rexquor\rr5rrrrrr_r"ras r8 __truediv__PolyElement.__truediv__sww#$9: : __R 88B<  K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[r**%% %$B==$ $ "! ! "rmcURnURU5nURU5$![a [s$f=fr[)r9rryr"rras r8rrPolyElement.__rtruediv__sEww $B88B<  "! ! "rgc^^^URRmURRnURmURRmUR (a UUU4SjnU$UUU4SjnU$)NcR>Uup#UupEUT :XaUnOT"X$5nUb UT"X554$gr[rY a_lm_a_lc b_lm_b_lca_lma_lcb_lmb_lcr domain_quorrs r8term_div'PolyElement._term_div..term_divs@& & 2: E(4E$ *T"888r:cd>Uup#UupEUT :XaUnOT"X$5nUbX5-(d UT"X554$gr[rYrs r8rrsC& & 2: E(4E  *T"888r:)r9rr5rqrrz)rr5rrrrs @@@r8 _term_divPolyElement._term_divsX YY ! !!!ZZ yy-- ?? 0 r:c4URnSn[U[5(aSnU/n[U5(d [ S5eU(d-U(aUR UR 4$/UR 4$UHnURU:wdM[ S5e [U5n[U5Vs/sHobR PM nnUR5nUR n UR5n UV s/sHoR5PM n n U(aSnSn Xe:ayU S:XasUR5nU "XU4XXX45nUb6UunnXvRUU45Xv'URXUU*45nSn OUS- nXe:aU S:XaMsU (d'UR5nU RXU45n X U(aMWUR:XaX- n U(aU(dUR U 4$USU 4$Xy4$s snfs sn f)aDivision algorithm, see [CLO] p64. fv array of polynomials return qv, r such that self = sum(fv[i]*qv[i]) + r All polynomials are required not to be Laurent polynomials. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> f = x**3 >>> f0 = x - y**2 >>> f1 = x - y >>> qv, r = f.div((f0, f1)) >>> qv[0] x**2 + x*y**2 + y**4 >>> qv[1] 0 >>> r y**6 FTr\z"self and f must have the same ringrr)r9r\rrfr]rrr|rrrr _iadd_monom_iadd_poly_monomr)rfvr9 ret_singlerzr`rqvr3rrfxexpvs divoccurredrtermexpv1rTs r8rPolyElement.divs8yy b+ & &JB2ww#$9: :yy$))++499}$Avv~ !EFF G!&q *Aii * IIK II>>#-/0Rr"R0AK%K1,~~'w%(BE%(O1LM##HE1E--uaj9BE**2551"+>A"#KFA%K1,(MM44/2G!a" 4?? " FA yy!|#!uax5L=+1s 4H;HcUn[U[5(aU/n[U5(d [S5eURnUR nUR nURnUR nUR5nURn UR5nURn U(aUHzn U"XR5n U cMU upU R5H.unnU"X5nU "UU5UU-- nU(dUU M)UUU'M0 UR5nUbUUU4n O= U unnUU;aUU==U- ss'OUUU'UU UR5nUbUUU4n U(aMU$r[)r\rrfr]r9r5rrrLTrrrfr)rGrzr9r5rrrrltfrgtqrSrTmgcgm1c1ltmltcs r8riPolyElement.rem#sq  a % %A1vv#$9: :vv{{(( II;;=dd FFHeec44(>DA"#++-B)"0 T]QrT1! !"$&AbE #0..*C!1S6k"S!8cFcMF AcFcFnn&?qv+C5a8r:c*URU5S$Nr)r)rzrs r8rqPolyElement.quoPsuuQx{r:cPURU5up#U(dU$[X5er[)rr$)rzrqrs r8ryPolyElement.exquoSs$uuQxH%a+ +r:cXRR;aUR5nOUnUup4URU5nUcXBU'U$XT- nU(aXRU'U$X# U$)aadd to self the monomial coeff*x0**i0*x1**i1*... unless self is a generator -- then just return the sum of the two. mc is a tuple, (monom, coeff), where monomial is (i0, i1, ...) Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> p = x**4 + 2*y >>> m = (1, 2) >>> p1 = p._iadd_monom((m, 5)) >>> p1 x**4 + 5*x*y**2 + 2*y >>> p1 is p True >>> p = x >>> p1 = p._iadd_monom((m, 5)) >>> p1 5*x*y**2 + x >>> p1 is p False )r9rrr)rmccpselfrrrTs r8rPolyElement._iadd_monom[sr8 99&& &YY[FF  JJt  9 4L JA t  L r:cbUnX3RR;aUR5nUupEURnURRR nURR nUR5H)upU"X5n U"X5X--n U (aXU 'M'X; M+ U$)aadd to self the product of (p)*(coeff*x0**i0*x1**i1*...) unless self is a generator -- then just return the sum of the two. mc is a tuple, (monom, coeff), where monomial is (i0, i1, ...) Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y, z = ring('x, y, z', ZZ) >>> p1 = x**4 + 2*y >>> p2 = y + z >>> m = (1, 2, 3) >>> p1 = p1._iadd_poly_monom(p2, (m, 3)) >>> p1 x**4 + 3*x*y**3*z**3 + 3*x*y**2*z**4 + 2*y )r9rrrr5rrrI) rrrrrSrTrrrrrkars r8rPolyElement._iadd_poly_monoms* "" "Bffww~~""ww++ HHJDAa#BMAC'E2F  r:c^URRU5mU(d[$TS:ag[U4SjUR 555$)zx The leading degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3,># UH oTv M g7fr[rYr_rrs r8ra%PolyElement.degree..<^EQx^)r9rrryr rzxrs @r8degreePolyElement.degree? FFLLOK U7166<<' 'S$sALLN';"<=> >r:c^URRU5mU(d[$TS:ag[U4SjUR 555$)zu The tail degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3,># UH oTv M g7fr[rYrs r8ra*PolyElement.tail_degree..rr)r9rrminr rs @r8 tail_degreePolyElement.tail_degreerr:c U(d[4URR-$[[ [ [ [UR56555$)zx A tuple containing tail degrees in all variables. Note that the degree of 0 is negative infinity (``float('-inf')``) ) rr9rlr{rDrrCrHr rs r8 tail_degreesPolyElement.tail_degreesrr:cHU(aURRU5$g)a Leading monomial tuple according to the monomial ordering. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y, z = ring('x, y, z', ZZ) >>> p = x**4 + x**3*y + x**2*z**2 + z**7 >>> p.leading_expv() (4, 0, 0) N)r9rrs r8rPolyElement.leading_expvs 99))$/ /r:c`URXRRR5$r[)rr9r5rrrs r8 _get_coeffPolyElement._get_coeffs!xxii..3344r:czUS:Xa%URURR5$URRU5(ac[ UR 55n[ U5S:Xa;USup4X@RRR:XaURU5$[SU-5e)a| Returns the coefficient that stands next to the given monomial. Parameters ========== element : PolyElement (with ``is_monomial = True``) or 1 Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y, z = ring("x,y,z", ZZ) >>> f = 3*x**2*y - x*y*z + 7*z**3 + 23 >>> f.coeff(x**2*y) 3 >>> f.coeff(x*y) 0 >>> f.coeff(1) 23 rrzexpected a monomial, got %s) rr9rrrCrfr|r5rr)rrrorrs r8rPolyElement.coeffs4 a<??499#7#78 8 YY ! !' * ***,-E5zQ$Qx II,,000??5116@AAr:cLURURR5$)z"Returns the constant coefficient. )rr9rrs r8rPolyElement.const styy3344r:c@URUR55$r[)rrrs r8rPolyElement.LC$st00233r:cXUR5nUcURR$U$r[)rr9rrs r8LMPolyElement.LM(s*  " <99'' 'Kr:cURRnUR5nU(a"URRRX'U$)z Leading monomial as a polynomial element. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> (3*x*y + y**2).leading_monom() x*y )r9rrr5rrr3rs r8 leading_monomPolyElement.leading_monom0s> IINN  " ii&&**AGr:cUR5nUc6URRURRR4$XR U54$r[)rr9rr5rrrs r8rPolyElement.LTEsL  " <II(($))*:*:*?*?@ @//$/0 0r:cdURRnUR5nUbXX'U$)zLeading term as a polynomial element. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> (3*x*y + y**2).leading_term() 3*x*y )r9rrrs r8 leading_termPolyElement.leading_termMs3 IINN  "  jAGr:c^TcURRmO[R"T5mT[La [ USSS9$[ UU4SjSS9$)Nc US$rrY)rs r8rs%PolyElement._sorted..hsqr:T)rxreversec>T"US5$rrY)rr6s r8rsrjs uQxr:)r9r6rr~r sorted)rrXr6s `r8_sortedPolyElement._sortedasL =IIOOE''.E C<##94H H##@$O Or:cZURU5VVs/sHup#UPM snn$s snnf)aOrdered list of polynomial coefficients. Parameters ========== order : :class:`~.MonomialOrder` or coercible, optional Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex, grlex >>> _, x, y = ring("x, y", ZZ, lex) >>> f = x*y**7 + 2*x**2*y**3 >>> f.coeffs() [2, 1] >>> f.coeffs(grlex) [1, 2] ro)rr6_rs r8rPPolyElement.coeffsls)0(,zz%'8:'881'8:::'cZURU5VVs/sHup#UPM snn$s snnf)aOrdered list of polynomial monomials. Parameters ========== order : :class:`~.MonomialOrder` or coercible, optional Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex, grlex >>> _, x, y = ring("x, y", ZZ, lex) >>> f = x*y**7 + 2*x**2*y**3 >>> f.monoms() [(2, 3), (1, 7)] >>> f.monoms(grlex) [(1, 7), (2, 3)] r)rr6rrs r8monomsPolyElement.monomss)0(,zz%'8:'885'8:::rcTUR[UR55U5$)aOrdered list of polynomial terms. Parameters ========== order : :class:`~.MonomialOrder` or coercible, optional Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex, grlex >>> _, x, y = ring("x, y", ZZ, lex) >>> f = x*y**7 + 2*x**2*y**3 >>> f.terms() [((2, 3), 2), ((1, 7), 1)] >>> f.terms(grlex) [((1, 7), 1), ((2, 3), 2)] )rrCrI)rr6s r8roPolyElement.termss 0||D.66r:c4[UR55$)z,Iterator over coefficients of a polynomial. )iterrFrs r8 itercoeffsPolyElement.itercoeffsDKKM""r:c4[UR55$)z)Iterator over monomials of a polynomial. )rrrs r8r PolyElement.itermonomsDIIK  r:c4[UR55$)z%Iterator over terms of a polynomial. )rrIrs r8rfPolyElement.itertermsDJJL!!r:c4[UR55$)z+Unordered list of polynomial coefficients. )rCrFrs r8 listcoeffsPolyElement.listcoeffsrr:c4[UR55$)z(Unordered list of polynomial monomials. )rCrrs r8 listmonomsPolyElement.listmonomsrr:c4[UR55$)z$Unordered list of polynomial terms. rrs r8 listtermsPolyElement.listtermsrr:cXRR;aX-$U(dUR5 gUHnX==U-ss'M U$)amultiply inplace the polynomial p by an element in the coefficient ring, provided p is not one of the generators; else multiply not inplace Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> p = x + y**2 >>> p1 = p.imul_num(3) >>> p1 3*x + 3*y**2 >>> p1 is p True >>> p = x >>> p1 = p.imul_num(3) >>> p1 3*x >>> p1 is p False N)r9rclear)r3rTrs r8rTPolyElement.imul_numsD4   3J GGI C FaKFr:cURRnURnURnUR 5H nU"X$5nM U$)z*Returns GCD of polynomial's coefficients. )r9r5rrr)rzr5contrrs r8rPolyElement.contentsB{{jj\\^Et#D$ r:cUR5nXRRR:XaX4$XR U54$)z,Returns content and a primitive polynomial. )rr9r5rr_)rzrs r8 primitivePolyElement.primitives;yy{ 66==%% %9 \\$'''r:cJU(dU$URUR5$)z5Divides all coefficients by the leading coefficient. )r_rrs r8monicPolyElement.monicsH<<% %r:cU(dURR$UR5VVs/sH up#X#U-4PM nnnURU5$s snnfr[)r9rrfr)rzrrrros r8rPolyElement.mul_groundsJ66;; 78{{}F}|u5'"}FuuU|GsAcURRnUR5VVs/sHup4U"X15U4PM nnnURU5$s snnfr[)r9rrIr)rzrrf_monomf_coeffros r8 mul_monomPolyElement.mul_monomsQvv** RSRYRYR[]R[>Ng</9R[]uuU|^sAc\Uup#U(aU(dURR$X RR:XaURU5$URRnUR 5VVs/sHupVU"XR5Xc-4PM nnnUR U5$s snnfr[)r9rrrrrIr)rzrrrrrrros r8mul_termPolyElement.mul_terms 66;;  ff'' '<<& &vv** XYX_X_XacXaDTG</?XacuuU|ds<B(c URRnU(d [S5eU(aXR:XaU$UR(a8UR nUR 5VVs/sHupEXC"XQ54PM nnnO3UR 5VVs/sHupEXQ-(aMXEU-4PM nnnURU5$s snnfs snnfr[)r9r5r]rrzrqrfr)rzrr5rqrrros r8r_PolyElement.quo_ground&s#$9: :AOH ??**CABPuc%m,EPE>?kkm`mleTYT])uqj)mE`uuU| Q`s1CC0 CcUup#U(d [S5eU(dURR$X RR:XaUR U5$UR 5nUR 5Vs/sH oT"XQ5PM nnURUVs/sH oUcMUPM sn5$s snfs snfr[)r]r9rrr_rrfr)rzrrrrtros r8quo_termPolyElement.quo_term6s #$9: :66;;  ff'' '<<& &;;=-.[[]<](1#]<uu%:%Qq%:;;=:sB9"B>,B>cjURRR(a>/nUR5H'up4XA-nXAS-:aXA- nUR X445 M) O(UR5VVs/sH up4X4U-4PM nnnUR U5nUR 5 U$s snnf)Nr)r9r5is_ZZrfrrr)rzr3rorrrs r8 trunc_groundPolyElement.trunc_groundEs 66==  E !  6>!IE e^, !.>?[[]L]\Uuai(]ELuuU|  Ms7B/cUnUR5nUR5nURRRX45nUR U5nUR U5nXRU4$r[)rr9r5rr_)rrrzfcgcrs r8extract_groundPolyElement.extract_groundYs[  YY[ YY[ffmm' LL  LL qyr:cU(d URRR$URRRnU"UR 5Vs/sH o2"U5PM sn5$s snfr[)r9r5rabsr)rz norm_func ground_absrs r8_normPolyElement._normesT66==%% %**JallnNnUz%0nNO ONsA4c,UR[5$r[)r3ryrs r8max_normPolyElement.max_normlwws|r:c,UR[5$r[)r3rErs r8l1_normPolyElement.l1_normor8r:c\URnU/[U5-nS/UR-nUH>nUR5H'n[ U5Hupx[ XGU5XG'M M) M@ [ U5HupyU (aMSXG'M [ U5n[SU55(aXC4$/n UHgnURn UR5H3up[X5VVs/sH up~X~-PM nnnX[ U5'M5 U RU 5 Mi XJ4$s snnf)Nrrc3*# UH oS:Hv M g7frrY)r_rrs r8ra&PolyElement.deflate..s!q!Avqs) r9rCrlr rrr{rfrrfrHr)rzrr9rUJr3rrrSrrHhIrrWNs r8deflatePolyElement.deflatersvvd1g  C NA%e,DAa=AD-( aLDA1! !H !q! ! !8O A AKKM),Q4af4#%( * HHQKt 5s,D( cURRnUR5H3up4[X15VVs/sH upVXV-PM nnnXB[ U5'M5 U$s snnfr[)r9rrfrHr{)rzr?rrBrrrWrCs r8inflatePolyElement.inflatesTvv{{ HA"%a)-)$!!#)A-"qN& .sA cfUnURRnUR(d5UR5upBUR5upQUR XE5nX!-R UR U55nUR(dURW5$UR5$r[) r9r5rzrrrqrrr)rrrzr5r+r,rTrAs r8rPolyElement.lcms| KKMEBKKMEB 2"A SIIaeeAh <<? "779 r:c*URU5S$r) cofactorsrzrs r8rPolyElement.gcds{{1~a  r:c"U(d!U(dURRnX"U4$U(dURU5up4nX4U4$U(dURU5up5nX4U4$[U5S:XaUR U5up4nX4U4$[U5S:XaUR U5up5nX4U4$UR U5unupUR U5up4nURU5URU5URU54$r)r9r _gcd_zeror| _gcd_monomrD_gcdrG)rzrrrAcffcfgr?s r8rLPolyElement.cofactorss66;;Dt# #++a.KAC3; ++a.KAC3;  Vq[,,q/KAC3;  Vq[,,q/KAC3; IIaL 6AffQi  ! ckk!nckk!n==r:cURRURRp2UR(aXU4$U*X2*4$r[)r9rrr)rzrrrs r8rPPolyElement._gcd_zeros:FFJJ T  C< 2tT> !r:c 2URnURRnURRnURnUR n[ UR55SupxXxpUR5HupU"X5n U"X5n M URX4/5n URU"Xy5U"X54/5nURUR5V V s/sHupU"X5U"X54PM sn n 5nXU4$s sn n fr) r9r5rrqrrrCrfr)rzrr9 ground_gcd ground_quorrmfcf_mgcd_cgcdrrrArSrTs r8rQPolyElement._gcd_monomsvv[[__ [[__ (( ** akkm$Q'ukkmFB +Eu)E$ EEE>" #eemB. 20EFGHeeUVU`U`UbcUb62mB. 20EFUbcds{ds+D cURnURR(aURU5$URR(aUR U5$UR X5$r[)r9r5is_QQ_gcd_QQr'_gcd_ZZ dmp_inner_gcd)rzrr9s r8rRPolyElement._gcdsRvv ;;  99Q<  [[  99Q< %%a+ +r:c[X5$r[rrMs r8rcPolyElement._gcd_ZZs a|r:cdUnURnURURR5S9nUR 5upRUR 5upaUR U5nUR U5nUR U5upxn UR U5nURUR5pzUR U5RURRX55nU R U5RURRX55n XxU 4$)Nr) r9rr5r|rrprcrrrrq) rrrzr9rnr\rrArSrTrTs r8rbPolyElement._gcd_QQs vv::T[[%9%9%;:<   JJx  JJx iil  JJt ttQWWY1ll4 ++DKKOOA,BCll4 ++DKKOOA,BCs{r:c>UnURnU(d X#R4$URnUR(aUR(dUR U5upVnOUR UR5S9nUR5upUR5upURU5nURU5nUR U5upVnURR X5upZn URU5nURU5nURU 5nURU 5nUR5n XR:XaXg4$XR*:XaU*U*pvXg4$URU 5nURU 5nXg4$)z Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> (2*x**2 - 2).cancel(x**2 - 2*x + 1) (2*x + 2, x - 1) r) r9rr5rzr{rLrr|rrprcanonical_unit) rrrzr9r5rr3rrncqcpus r8cancelPolyElement.cancelsd vvhh; F$9$9kk!nGA!zz):z;HNN$EBNN$EB 8$A 8$Akk!nGA! 11"9IA2 4 A 4 A R A R A     ? t ::+ 2rq t  QA QAt r:cdURRnURUR5$r[)r9r5rkr)rzr5s r8rkPolyElement.canonical_unit6 s$$$QTT**r:cURnURU5nURU5nURnUR 5H9upgXc(dMUR Xd5nUR XvU-5XX'M; U$)zComputes partial derivative in ``x``. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring("x,y", ZZ) >>> p = x + x**2*y**3 >>> p.diff(x) 2*x*y**3 + 1 )r9rrrrfrr) rzrr9rrSrrres r8diffPolyElement.diff: syvv JJqM    " II;;=KDww&&t/u!W}5)r:c,S[U5s=:aURR::a;O O8UR[ [ URR U555$[SURR<S[U5<35e)Nrz expected at least 1 and at most z values, got )r|r9rlevaluaterCrHr3r)rzrFs r8rQPolyElement.__call__S sb s6{ *affll *::d3qvv{{F#;<= =TUTZTZT`T`beflbmno or:cUn[U[5(abUc_USUSSsupBnURXB5nU(dU$UVVs/sHupRURU5U4PM nnnURU5$URnUR U5nUR RU5nURS:Xa<UR RnUR5HuupXX)--- nM U$URU5Rn UR5HFupXU SUXS-S-pXU --n X;aXU -n U (aXU 'M5X M9U (dMBXU 'MH U $s snnf)Nrr) r\rCrxrr9rr5rrlrrf) rrrqrzXYr9rresultrHrrrs r8rxPolyElement.evaluateY sg  a  19!aeIFQA 1 A3461!qvvay!n16zz!}$vv JJqM KK   " ::?[[%%F {{} *$ -M99Q<$$D !  8U2AYst%<5d =!K/E&+U  Ku&+U !.KA7sE5cnUn[U[5(a!UcUHupBURXB5nM U$URnUR U5nUR R U5nURS:XaKUR RnUR5HuupXyX(--- nM URU5$URn UR5HIupXU SUS-XS-S-pXU--n X;aXU -n U (aXU 'M8X M<U (dMEXU 'MK U $)Nrrn) r\rCsubsr9rr5rrlrrfr) rrrqrzr{r9rr}rHrrrs r8rPolyElement.subs s'  a  19FF1LHvv JJqM KK   " ::?[[%%F {{} *$ -??6* *99D !  8U2AY%5cd %C5d =!K/E&+U  Ku&+U !.Kr:c^^^UR5nURnURnU(dXR/4$[ U5Vs/sHoBR US-5PM snm0mUU4Sjn[ [ US- 55n[ [ USS55nURnU(aSupn [UR55HMunumn [U4SjU55(dM%[S[UT555n X:dMHU TU pn MO U S:waXsmn OO~/n[TTSSS -5HunnURUU- 5 M XR[U5U 5- nU n[U5HupCUU"XC5-nM UU-nU(aM[ [URT55nXU4$s snf) a Rewrite *self* in terms of elementary symmetric polynomials. Explanation =========== If this :py:class:`~.PolyElement` belongs to a ring of $n$ variables, we can try to write it as a function of the elementary symmetric polynomials on $n$ variables. We compute a symmetric part, and a remainder for any part we were not able to symmetrize. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> R, x, y = ring("x,y", ZZ) >>> f = x**2 + y**2 >>> f.symmetrize() (x**2 - 2*y, 0, [(x, x + y), (y, x*y)]) >>> f = x**2 - y**2 >>> f.symmetrize() (x**2 - 2*y, -2*y**2, [(x, x + y), (y, x*y)]) Returns ======= Triple ``(p, r, m)`` ``p`` is a :py:class:`~.PolyElement` that represents our attempt to express *self* as a function of elementary symmetric polynomials. Each variable in ``p`` stands for one of the elementary symmetric polynomials. The correspondence is given by ``m``. ``r`` is the remainder. ``m`` is a list of pairs, giving the mapping from variables in ``p`` to elementary symmetric polynomials. The triple satisfies the equation ``p.compose(m) + r == self``. If the remainder ``r`` is zero, *self* is symmetric. If it is nonzero, we were not able to represent *self* as symmetric. See Also ======== sympy.polys.polyfuncs.symmetrize References ========== .. [1] Lauer, E. Algorithms for symmetrical polynomials, Proc. 1976 ACM Symp. on Symbolic and Algebraic Computing, NY 242-247. https://dl.acm.org/doi/pdf/10.1145/800205.806342 rc6>X4T;a TUU-TX4'TX4$r[rY)rrH poly_powersrUs r8get_poly_power.PolyElement.symmetrize..get_poly_power s.v[(&+Ahk QF#v& &r:rr)rNNc3@># UHnTUTUS-:v M g7frrY)r_rrs r8ra)PolyElement.symmetrize.. s"AAuQx5Q</rGc3.# UH upX-v M g7fr[rY)r_rHrSs r8rar s E1D1DsNrn)rr9rlrrrIrCrrorfryrHrrr{r3)rrzr9rHrrrweights symmetric_height_monom_coeffrheight exponentsrm2productrrrrUs @@@r8 symmetrizePolyElement.symmetrize sv IIKvv JJii# #388<8a$$QqS)8<  ' uQU|$uQ2'II &4 #GV%.qwwy%9!>E5AAAA EWe1D EEF'28% &:"}% uIeU12Y%56B  b)7 uY'7? ?IG!),>!//- LA1a4s499e,-W$$S=sGc^ URnURn[[UR[ UR 555m UbX4/nO^[U[5(a [U5nO=[U[5(a[UR5U 4SjS9nO [S5e[U5H unupT UURU54XV'M" UR5H`up[U5nURn UHupXSsoU 'U (dMXU --n M U R![#U5U 45n XJ- nMb U$)Nc>TUS$rrY)rgens_maps r8rs%PolyElement.compose..$ s x!~r:rwz9expected a generator, value pair a sequence of such pairsr)r9rrGrHr3rrlr\rCrrIrrrrfrrr{)rzrrqr9r replacementsrrrrsubpolyrrHrs @r8r?PolyElement.compose s+vvyyDIIuTZZ'89: =F8L!T""#Aw At$$%aggi5MN  !\]]"<0IAv'{DMM!,<=LO1KKMLEKEhhG$#h 81!tOG% &&e e'<=G OD* r:cUnURRU5nUR5VVs/sHupVXTU:XdMXV4PM nnnU(dURR$[ U6upUVs/sHoUSUS-XTS-S-PM nnURR [ [ X555$s snnfs snf)am Coefficient of ``self`` with respect to ``x**deg``. Treating ``self`` as a univariate polynomial in ``x`` this finds the coefficient of ``x**deg`` as a polynomial in the other generators. Parameters ========== x : generator or generator index The generator or generator index to compute the expression for. deg : int The degree of the monomial to compute the expression for. Returns ======= :py:class:`~.PolyElement` The coefficient of ``x**deg`` as a polynomial in the same ring. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x, y, z = ring("x, y, z", ZZ) >>> p = 2*x**4 + 3*y**4 + 10*z**2 + 10*x*z**2 >>> deg = 2 >>> p.coeff_wrt(2, deg) # Using the generator index 10*x + 10 >>> p.coeff_wrt(z, deg) # Using the generator 10*x + 10 >>> p.coeff(z**2) # shows the difference between coeff and coeff_wrt 10 See Also ======== coeff, coeffs Nrnr)r9rrfrrHrJrG) rrdegr3rrSrTrorrPs r8 coeff_wrtPolyElement.coeff_wrt9 sT  FFLLO$%KKMAMDAQTS[!MA66;; e4:;FqBQ%$,q56*F;vvS%8 9::B >> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2 >>> f.prem(g) # first generator is chosen by default if it is not given -4*y + 4 >>> f.rem(g) # shows the difference between prem and rem x**2 + x*y >>> f.prem(g, y) # generator is given 0 >>> f.prem(g, 1) # generator index is given 0 See Also ======== pdiv, pquo, pexquo, sympy.polys.domains.ring.Ring.rem rr\rr9rrr]rr3)rrrrzdfdgrdrrClc_gxplc_rrWRrrTs r8premPolyElement.premn sl  FFLLO XXa[ XXa[ 6#$9: :2 7H GaK{{1! VV[[^;;q%D7AEqA25 AA!Bw Iu r:cUnURRU5nURU5nURU5nUS:a [S5eX#UpnXE:aXg4$XE- S-n UR X%5n URR Un UR X(5n X- U S- pXj-nXX---nXz-nX-X--nUU- nURU5nX:aOMQX-nUU-nUU-nXg4$)a Computes the pseudo-division of the polynomial ``self`` with respect to ``g``. The pseudo-division algorithm is used to find the pseudo-quotient ``q`` and pseudo-remainder ``r`` such that ``m*f = g*q + r``, where ``m`` represents the multiplier and ``f`` is the dividend polynomial. The pseudo-quotient ``q`` and pseudo-remainder ``r`` are polynomials in the variable ``x``, with the degree of ``r`` with respect to ``x`` being strictly less than the degree of ``g`` with respect to ``x``. The multiplier ``m`` is defined as ``LC(g, x) ^ (deg(f, x) - deg(g, x) + 1)``, where ``LC(g, x)`` represents the leading coefficient of ``g``. It is important to note that in the context of the ``prem`` method, multivariate polynomials in a ring, such as ``R[x,y,z]``, are treated as univariate polynomials with coefficients that are polynomials, such as ``R[x,y][z]``. When dividing ``f`` by ``g`` with respect to the variable ``z``, the pseudo-quotient ``q`` and pseudo-remainder ``r`` satisfy ``m*f = g*q + r``, where ``deg(r, z) < deg(g, z)`` and ``m = LC(g, z)^(deg(f, z) - deg(g, z) + 1)``. In this function, the pseudo-remainder ``r`` can be obtained using the ``prem`` method, the pseudo-quotient ``q`` can be obtained using the ``pquo`` method, and the function ``pdiv`` itself returns a tuple ``(q, r)``. Parameters ========== g : :py:class:`~.PolyElement` The polynomial to divide ``self`` by. x : generator or generator index, optional The main variable of the polynomials and default is first generator. Returns ======= :py:class:`~.PolyElement` The pseudo-division polynomial (tuple of ``q`` and ``r``). Raises ====== ZeroDivisionError : If ``g`` is the zero polynomial. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2 >>> f.pdiv(g) # first generator is chosen by default if it is not given (2*x + 2*y - 2, -4*y + 4) >>> f.div(g) # shows the difference between pdiv and div (0, x**2 + x*y) >>> f.pdiv(g, y) # generator is given (2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0) >>> f.pdiv(g, 1) # generator index is given (2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0) See Also ======== prem Computes only the pseudo-remainder more efficiently than `f.pdiv(g)[1]`. pquo Returns only the pseudo-quotient. pexquo Returns only an exact pseudo-quotient having no remainder. div Returns quotient and remainder of f and g polynomials. rr\rr)rrrrzrrrrrrCrrrrWQrrrTs r8pdivPolyElement.pdiv s`  FFLLO XXa[ XXa[ 6#$9: :b 74K GaK{{1! VV[[^;;q%D7AEqA25L AA25 AAA!Bw%( G E Et r:c.UnURX5S$)a Polynomial pseudo-quotient in multivariate polynomial ring. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2*y >>> h = 2*x + 2 >>> f.pquo(g) 2*x >>> f.quo(g) # shows the difference between pquo and quo 0 >>> f.pquo(h) 2*x + 2*y - 2 >>> f.quo(h) # shows the difference between pquo and quo 0 See Also ======== prem, pdiv, pexquo, sympy.polys.domains.ring.Ring.quo r)r)rrrrzs r8pquoPolyElement.pquoG s6 vva|Ar:chUnURX5upEUR(aU$[X15e)a< Polynomial exact pseudo-quotient in multivariate polynomial ring. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2*y >>> h = 2*x + 2 >>> f.pexquo(g) 2*x >>> f.exquo(g) # shows the difference between pexquo and exquo Traceback (most recent call last): ... ExactQuotientFailed: 2*x + 2*y does not divide x**2 + x*y >>> f.pexquo(h) Traceback (most recent call last): ... ExactQuotientFailed: 2*x + 2 does not divide x**2 + x*y See Also ======== prem, pdiv, pquo, sympy.polys.domains.ring.Ring.exquo )rrr$)rrrrzrrs r8pexquoPolyElement.pexquoe s/: vva| 99H%a+ +r:cUnURRU5nURU5nURU5nXE:aXpXTpTUS:XaSS/$US:XaUS/$X1/nXE- nSUS--nURX5n X-n UR X%5n X-n SU /n U *n U (aU RU5n UR U 5 XXU - 4up1pWU *X--nURX5n U R U5n UR X-5n US:aU *U-nXS- -nUR U5n OU *n U R U *5 U (aMU$)a Computes the subresultant PRS of two polynomials ``self`` and ``g``. Parameters ========== g : :py:class:`~.PolyElement` The second polynomial. x : generator or generator index The variable with respect to which the subresultant sequence is computed. Returns ======= R : list Returns a list polynomials representing the subresultant PRS. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2*y + x*y >>> g = x + y >>> f.subresultants(g) # first generator is chosen by default if not given [x**2*y + x*y, x + y, y**3 - y**2] >>> f.subresultants(g, 0) # generator index is given [x**2*y + x*y, x + y, y**3 - y**2] >>> f.subresultants(g, y) # generator is given [x**2*y + x*y, x + y, x**3 + x**2] rrr)r9rrrrrry)rrrrzrHrSrdrrrAlcrTSrr3rs r8 subresultantsPolyElement.subresultants siD  FFLLO HHQK HHQK 5qq 6q6M 6q6M F E QUO FF1L E[[  G F B A HHQKqa%JA!af Aq A AQ"B1uSQJa%LGGAJC HHaRL'a*r:c8URRX5$r[)r9dmp_half_gcdexrMs r8 half_gcdexPolyElement.half_gcdex svv$$Q**r:c8URRX5$r[)r9 dmp_gcdexrMs r8gcdexPolyElement.gcdex vv%%r:c8URRX5$r[)r9 dmp_resultantrMs r8 resultantPolyElement.resultant svv##A))r:c8URRU5$r[)r9dmp_discriminantrs r8 discriminantPolyElement.discriminant svv&&q))r:cURR(aURRU5$[S5e)Nzpolynomial decomposition)r9r) dup_decomposer%rs r8 decomposePolyElement.decompose s0 66  66''* *-.HI Ir:cURR(aURRX5$[S5e)Nzshift: use shift_list instead)r9r) dup_shiftr%rzrqs r8shiftPolyElement.shift s0 66  66##A) )-.MN Nr:c8URRX5$r[)r9 dmp_shiftrs r8 shift_listPolyElement.shift_list rr:cURR(aURRU5$[S5e)Nzsturm sequence)r9r) dup_sturmr%rs r8sturmPolyElement.sturm s0 66  66##A& &-.>? ?r:c8URRU5$r[)r9 dmp_gff_listrs r8gff_listPolyElement.gff_list vv""1%%r:c8URRU5$r[)r9dmp_normrs r8normPolyElement.norm svvq!!r:c8URRU5$r[)r9 dmp_sqf_normrs r8sqf_normPolyElement.sqf_norm rr:c8URRU5$r[)r9 dmp_sqf_partrs r8sqf_partPolyElement.sqf_part rr:c4URRXS9$)N)rf)r9 dmp_sqf_list)rzrfs r8sqf_listPolyElement.sqf_list svv""1"..r:c8URRU5$r[)r9dmp_factor_listrs r8 factor_listPolyElement.factor_list svv%%a((r:)rr9r[)F)rrKrLrMrNrVr^rrcrrrrrprtrsrrrrrrrrrrrrrrr9rrr]rPrrrrrrrrrrrrr rrrr!r$r'r,r*r2r1r=r7rHrGrFrErbr^rkrjrsrvrzrrrrrirqryrrrrrrrrrrrrrrrrrPrrorr rfrrrrTrrrrrrr_r$r(r`r-r3r6r:rDrGrrrLrPrQrRrcrbrorkrurQrxrrr?rrrrrrrrrrrrrrrrrrrrrR __classcell__)rs@r8rrJsU? K/%3 E 8> =M" 44G0)"  2*>"H.`++MM==55558888**11@@@@## ++ GG R4l(4l82h:4(l :#J:,%,%,%, BJX+Z,*X#J= ?= ?(5#BJ544*11( P;4;474#!"#!"!F (&  <$J PB !>," ,*6p+2p *X%Nk%Z@3;jYv||<#,JXz+&**J O &@ &"&&/))r:rN)r6zMonomialOrder | str)QrN __future__roperatorrrrrrr functoolsr typesr sympy.core.cacher sympy.core.exprr sympy.core.intfuncrsympy.core.symbolrrresympy.core.sympifyrrsympy.ntheory.multinomialrsympy.polys.compatibilityrsympy.polys.constructorrsympy.polys.densebasicrrrsympy.polys.domains.domainr!sympy.polys.domains.domainelementr"sympy.polys.domains.polynomialringrsympy.polys.heuristicgcdrsympy.polys.monomialsrsympy.polys.orderingsr r!sympy.polys.polyerrorsr"r#r$r%sympy.polys.polyoptionsr}r&rr'sympy.polys.polyutilsr(r)r*sympy.printing.defaultsr+sympy.utilitiesr,r-sympy.utilities.iterablesr.sympy.utilities.magicr/r9r<r@rVrhr2rGrrYr:r8rs"--$ #93>,4CC-;=+-466GG==3+1)58!!<!$<!$<22h @CCL N')-+tN')r: