*hPSrSSKJrJrJrJrJrJrJrJ r J r J r J r J r JrJrJrJrJrJrJrJrJrJr SSKJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+ SSK,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r; SSKr> SSK?J@r@ SSKAJBrBJCrCJDrDJErEJFrF SrGS rHS rIS rJS rKS rLSrMSrNSrOSrPSrQSrRSrSS@SjrTSrUSrVSrWSrXSrYSrZSr[S@Sjr\Sr]Sr^S r_S!r`S"raS#rbS$rcS%rdS&reS'rfS(rgS)rhS*riS+rjS,rkS-rlS.rmS/rnS0roS1rpS2rqS3rrS4rsS5rtS6ruS7rvS8rwS9rxS:ryS;rzS<r{SAS=jr|SAS>jr}g?)BzEEuclidean algorithms, GCDs, LCMs and polynomial remainder sequences. ) dup_sub_muldup_negdmp_negdmp_adddmp_subdup_muldmp_muldmp_powdup_divdmp_divdup_remdup_quodmp_quodup_premdmp_premdup_mul_grounddmp_mul_ground dmp_mul_termdup_quo_grounddmp_quo_ground dup_max_norm dmp_max_norm) dup_strip dmp_raisedmp_zerodmp_one dmp_ground dmp_one_p dmp_zero_p dmp_zeros dup_degree dmp_degree dmp_degree_indup_LCdmp_LC dmp_ground_LCdmp_multi_deflate dmp_inflate dup_convert dmp_convertdmp_apply_pairs)dup_clear_denomsdmp_clear_denomsdup_diffdmp_diffdup_evaldmp_eval dmp_eval_in dup_truncdmp_ground_trunc dup_monicdmp_ground_monic dup_primitivedmp_ground_primitive dup_extractdmp_ground_extractgf_intgf_crt)query)MultivariatePolynomialErrorHeuristicGCDFailedHomomorphismFailed NotInvertible DomainErrorcUR(d[SU-5eUR//pCU(a&[XU5upVXpU[ X5XB5pCU(aM&[ U[ X5U5n[X5nX04$)aF Half extended Euclidean algorithm in `F[x]`. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> R.dup_half_gcdex(f, g) (-1/5*x + 3/5, x + 1) z(Cannot compute half extended GCD over %s)is_FieldrConer rrr$r5)fgKabqrs T/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/polys/euclidtools.pydup_half_gcdexrO2sx& ::DqHII EE7Bq qQ1+aA)1 ! q&,*A!A 4Kc>U(d [XU5$[X5e)z Half extended Euclidean algorithm in `F[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) )rOr?rGrHurIs rNdmp_half_gcdexrTUs aA&&)!//rPcV[XU5up4[XCX5n[XQU5nX6U4$)aS Extended Euclidean algorithm in `F[x]`. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> R.dup_gcdex(f, g) (-1/5*x + 3/5, 1/5*x**2 - 6/5*x + 2, x + 1) )rOrr)rGrHrIshFts rN dup_gcdexrZfs3& ! "DAA!AaA 7NrPc>U(d [XU5$[X5e)z Extended Euclidean algorithm in `F[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) )rZr?rRs rN dmp_gcdexr\s q!!)!//rPcl[XU5up4XBR/:Xa [X1U5$[S5e)a8 Compute multiplicative inverse of `f` modulo `g` in `F[x]`. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> f = x**2 - 1 >>> g = 2*x - 1 >>> h = x - 1 >>> R.dup_invert(f, g) -4/3 >>> R.dup_invert(f, h) Traceback (most recent call last): ... NotInvertible: zero divisor z zero divisor)rOrFr rB)rGrHrIrVrWs rN dup_invertr^s5. ! "DAUUG|qQN++rPc>U(d [XU5$[X5e)z Compute multiplicative inverse of `f` modulo `g` in `F[X]`. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) )r^r?rRs rN dmp_invertr`s !"")!//rPcX/n[XU5nU(a(URU5 Xp[XU5nU(aM(U$)a Euclidean polynomial remainder sequence (PRS) in `K[x]`. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5 >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21 >>> prs = R.dup_euclidean_prs(f, g) >>> prs[0] x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5 >>> prs[1] 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21 >>> prs[2] -5/9*x**4 + 1/9*x**2 - 1/3 >>> prs[3] -117/25*x**2 - 9*x + 441/25 >>> prs[4] 233150/19773*x - 102500/6591 >>> prs[5] -1288744821/543589225 )r append)rGrHrIprsrWs rNdup_euclidean_prsrdsD: &CaA  1 1 A!  ! JrPc>U(d [XU5$[X5e)z Euclidean polynomial remainder sequence (PRS) in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) )rdr?rRs rNdmp_euclidean_prsrf  q)))!//rPcX/n[[XU5U5upEU(a4URU5 Xp[[XU5U5upEU(aM4U$)a Primitive polynomial remainder sequence (PRS) in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5 >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21 >>> prs = R.dup_primitive_prs(f, g) >>> prs[0] x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5 >>> prs[1] 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21 >>> prs[2] -5*x**4 + x**2 - 3 >>> prs[3] 13*x**2 + 25*x - 49 >>> prs[4] 4663*x - 6150 >>> prs[5] 1 )r7rrb)rGrHrIrc_rWs rNdup_primitive_prsrjsV: &C !*A .DA  1 1XaA.2 ! JrPc>U(d [XU5$[X5e)z Primitive polynomial remainder sequence (PRS) in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) )rjr?rRs rNdmp_primitive_prsrl#rgrPcb[U5n[U5nX4:aXpXCpCU(d//4$U(dU/UR/4$X/nX4- nUR*US--n[XU5n[XU5n[ X5n X-n URU /n U *n U(a[U5n UR U5 XXU - 4uppFU *X--n[XU5n[ XU5n[ X5n US:aXS- -n URU *U-U 5n OU *n U R U *5 U(aMX[4$)a Subresultant PRS algorithm in `K[x]`. Computes the subresultant polynomial remainder sequence (PRS) and the non-zero scalar subresultants of `f` and `g`. By [1] Thm. 3, these are the constants '-c' (- to optimize computation of sign). The first subdeterminant is set to 1 by convention to match the polynomial and the scalar subdeterminants. If 'deg(f) < deg(g)', the subresultants of '(g,f)' are computed. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_inner_subresultants(x**2 + 1, x**2 - 1) ([x**2 + 1, x**2 - 1, -2], [1, 1, 4]) References ========== .. [1] W.S. Brown, The Subresultant PRS Algorithm. ACM Transaction of Mathematical Software 4 (1978) 237-249 )r!rFrrr$rbrquo)rGrHrInmRdrKrWlccSkrLs rNdup_inner_subresultantsrx4sH8 1 A1 Au11 2v sQUUG| A A %%1q5AqAqQA B A  A A qM  1!e^ a C!$J Q1  1 # A\ q5E AsQh"AA ! ' !* 4KrPc [XU5S$)z Computes subresultant PRS of two polynomials in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2] r)rxrGrHrIs rNdup_subresultantsr{s #1 +A ..rPcU(aU(dUR/4$[XU5up4[US5S:aURU4$USU4$)z Resultant algorithm in `K[x]` using subresultant PRS. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_prs_resultant(x**2 + 1, x**2 - 1) (4, [x**2 + 1, x**2 - 1, -2]) r)zerorxr!)rGrHrIrrrvs rNdup_prs_resultantrsQ A| "1 +DA!B%1{ R5!8OrPcFU(a [XU5$[XU5S$)z Computes resultant of two polynomials in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_resultant(x**2 + 1, x**2 - 1) 4 r)r)rGrHrI includePRSs rN dup_resultantrs& q)) Q1 %a ((rPc U(d [XU5$[X5n[X5nXE:aXpXTpT[X5(a//4$US- n[X5(aU/[URU5/4$X/nXE- n[ [UR*U5US-Xc5n [ XX#5n [XSX#5n [X5n [ XXc5n [URU5U /n [XU5n [X5(d[X5nURU 5 XXU- 4uppX[[XU5[ XXc5Xc5n [ XX#5n U Vs/sHn[XXc5PM n n[X5n US:a4[ [XU5XU5n[ XS- Xc5n[UUXc5n O [XU5n U R[XU55 [X5(dMX}4$s snf)a Subresultant PRS algorithm in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9 >>> a = 3*x*y**4 + y**3 - 27*y + 4 >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16 >>> prs = [f, g, a, b] >>> sres = [[1], [1], [3, 0, 0, 0, 0], [-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]] >>> R.dmp_inner_subresultants(f, g) == (prs, sres) True rnr) rxr"rrrFr rrr%rrbr r)rGrHrSrIrprqvrrrsrKrWrtrurvrwchprLs rNdmp_inner_subresultantsrs. &qQ//1A1Au11!2v  AA!sZq)*** A A AEE61%q1ua3AqAQ1a#A BqA AEE1 q!AaA q   1!e^ a GB1%A!' / Q1 -. 0QrgbQ"Q 0 A\ q5q)13Aq5!'A1a#Aq!A q!"+. 4K 1sG6c [XX#5S$)al Computes subresultant PRS of two polynomials in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9 >>> a = 3*x*y**4 + y**3 - 27*y + 4 >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16 >>> R.dmp_subresultants(f, g) == [f, g, a, b] True r)rrRs rNdmp_subresultantsrs( #1 .q 11rPcU(d [XU5$[X5(d[X5(a[US- 5/4$[XX#5upE[ USU5S:a[US- 5U4$USU4$)a Resultant algorithm in `K[X]` using subresultant PRS. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9 >>> a = 3*x*y**4 + y**3 - 27*y + 4 >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16 >>> res, prs = R.dmp_prs_resultant(f, g) >>> res == b # resultant has n-1 variables False >>> res == b.drop(x) True >>> prs == [f, g, a, b] True rnr}r)rrrrr")rGrHrSrIrrrvs rNdmp_prs_resultantr(s}4  q))!:a++Q$$ "1 .DA!B%aQ## R5!8OrPc U(d[[XU5SU-U5$US- n[X5n[X5n[USU5n[USU5n Xi-Xx--n UR/UR*p[ U5n [ U 5U ::GaLXR- n X:Xa [S5e[U[X5SX45n[X5U:Xa'[U[X5SX45n[X5U:XaOMm[XX%U5n[XXT5nU(d[U/5n[U/5nOU/nU/nUR[XU5U5n[U UU5n[UUSU5n[!U[#UUXT5XT5n[%U UXT5n ['XXT5n [)XRU */U5n [+XU5n [ U 5U ::aGMLU $)z Compute resultant of `f` and `g` modulo a prime `p`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x + y + 2 >>> g = 2*x*y + x + 3 >>> R.dmp_zz_modular_resultant(f, g, 5) -2*y**2 + 1 rrnno luck)r<rr"r#rFrr!rAr2dmp_zz_modular_resultantr1rinvertr0rrr rrr4rr3)rGrHrrSrIrrprqNMBDrJrMrXGrrersrus rNrrPs" 'a03a7;; AA1A1AaAAaAA ac A EE7QUUFq A Q-1  JAv(33Ava|Q5A!1$6!<A9a#q( %Q1 3 Q1 1#A1#AAA HHXaA& * 1a # aAq ! Awq!Q*A 1 Aq!  Q1 ( Ar{A & aA G Q-1 J HrPc8[[X/X#/U5X#-5$)z2Wrapper of CRT for Collins's resultant algorithm. r;)rMrrPrrIs rN _collins_crtrs &!!+QS 11rPc[X5n[X5nUS:dUS:a[US- 5$[XU5n[XU5n[XU5n[XU5n US- n U"S5UR U"XE-55-Xe--Xt--n[U 5UR UR pn SSKJn X::aU"U"U 55n X-(a X-(d$U"U"U 55n X-(dMX-(dM$[X X#5n[XX#5n[UUXU5nURU 5(aUn O[U U[XU4X5n X-n X::aMU $![a Mf=f)z Collins's modular resultant algorithm in `Z[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x + y + 2 >>> g = 2*x*y + x + 3 >>> R.dmp_zz_collins_resultant(f, g) -2*y**2 - 5*y + 1 rrn) nextprime)r"rrr& factorialrF sympy.ntheoryrr4rrAis_oner+r)rGrHrSrIrprqArrJrKrrMrrrrXrrrs rNdmp_zz_collins_resultantrsj$ 1A1A1uAAQ1AQ1AaAAaAA AA !Q[[15 ""14',Aqk155!%%!A' & ilO5!%)A,A55!%% Q1 ( Q1 ( (AqQ7A 88A;;A1lQ1IqDA ' &* H"   sE%% E32E3cr[X5n[X5nUS:dUS:a[US- 5$UR5n[XX65upp[XX65up[ XX65n[ XX65n[ XX&5n [ XS- Xc5n UR Xu-X--U5n [XUS- U5$)z Collins's modular resultant algorithm in `Q[X]`. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x,y = ring("x,y", QQ) >>> f = QQ(1,2)*x + y + QQ(2,3) >>> g = 2*x*y + x + 3 >>> R.dmp_qq_collins_resultant(f, g) -2*y**2 - 7/3*y + 5/6 rrn)r"rget_ringr-r*rconvertr) rGrHrSK0rprqK1cfcgrMrus rNdmp_qq_collins_resultantrs" 1A1A1uAA B Q2 *EB Q2 *EBA"!AA"!A q-AA1ub%A 2525="%A !Ar **rPc@U(d [XX4S9$U(a [XX#5$UR(a.UR(a[ S5(a [ XX#5$O-UR (a[ S5(a [XX#5$[XX#5S$)a  Computes resultant of two polynomials in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = 3*x**2*y - y**3 - 4 >>> g = x**2 + x*y**3 - 9 >>> R.dmp_resultant(f, g) -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16 )rUSE_COLLINS_RESULTANTr)rrrEis_QQr>ris_ZZr)rGrHrSrIrs rN dmp_resultantrs|" Q1<< q,,zz 77u455+A!7 7 77u455+A!7 7 Q1 ( ++rPc[U5nUS::a UR$SX"S- -S--n[X5n[U[ USU5U5nUR XTU"U5-5$)z Computes discriminant of a polynomial in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_discriminant(x**2 + 2*x + 3) -8 rr}rnr)r!r~r$rr.ro)rGrIrsrVrurMs rNdup_discriminantr#si 1 AAvvv A1uI!# $ 1L !XaA. 2uuQ!A$rPc U(d [X5$[X5US- pCUS::a [U5$SX3S- -S--n[X5n[ U[ USX5X5n[ Xb"U5XB5n[XvXB5$)z Computes discriminant of a polynomial in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y,z,t = ring("x,y,z,t", ZZ) >>> R.dmp_discriminant(x**2*y + x*z + t) -4*y*t + z**2 rnrr}r)rr"rr%rr/rr)rGrSrIrsrrVrurMs rNdmp_discriminantr>s %% a QUqAv{ A1uI!# $ 1L !XaA11 8 1adA )qQ""rPchU(d U(d///4$U(dIUR[X55(aU/UR/4$[X5/UR*/4$U(dHUR[X55(aXR//4$[X5UR*//4$g)3Handle trivial cases in GCD algorithm over a ring. N)is_nonnegativer$rFrrzs rN_dup_rr_trivial_gcdr]s 2rz   F1L ) )b155'> !1="vh. .   F1L ) )uugr> !1=AEE6(B. . rPcU(d U(d///4$U(d[X5/[X5/4$U(d[X5[X5//4$g)4Handle trivial cases in GCD algorithm over a field. N)r5r$rzs rN_dup_ff_trivial_gcdrosJ 2rz VA\N22 22rPc[X5n[X5n[XU5=(d [XU5nU(aU(a[[SX#55$U(adUR [ XU55(aU[ U5[X#54$[XU5[ U5[UR*U54$U(adUR [ XU55(aU[X#5[ U54$[XU5[UR*U5[ U54$U(a [X#5X4$[S5(a [XX#5$g)rUSE_SIMPLIFY_GCDN) rrtupler rr&rrrrrFr>_dmp_simplify_gcd)rGrHrSrIzero_fzero_gif_contain_ones rN_dmp_rr_trivial_gcdr{s  F  FqQ'=9Q1+=N &Yq!'((   M!2 3 3hqk71=0 01#Xa[*aeeVQ2GG G   M!2 3 3gamXa[0 01#Z%:HQKG G q}a"" ! " " q,,rPc z[X5n[X5nU(aU(a[[SX#55$U(a,[XU5[ U5[ [ XU5U54$U(a,[XU5[ [ XU5U5[ U54$[S5(a [XX#5$g)rrrN) rrr r6rrr&r>r)rGrHrSrIrrs rN_dmp_ff_trivial_gcdrs  F  F &Yq!'((  q) =q1157 7  q)=q115   ! " " q,,rPc [X5n[X5nUS:aUS:agU(dU(d[X5n[X5nO6U(d[X5n[XU5nO[XU5n[X5nUS- n[XgX5n UV s/sHn [ XX5PM n n UV s/sHn [ XX5PM n n U /X4$s sn fs sn f)z7Try to eliminate `x_0` from GCD computation in `K[X]`. rNrn)r"r% dmp_contentdmp_gcdr)rGrHrSrIdfdgrXrrrWrcffrcfgs rNrrs A B A B Av"q& " 1L 1Lq AA!$AA!$Aq A AAaA+, .1RGB1 1C .+, .1RGB1 1C . 3= / .s C 0Cc:[XU5nUbU$[X5upE[X5upgURXF5n[XWU5Sn [X5upXR [ X55-n[ XU5n [X U5n [XU5n XU 4$)a9 Computes polynomial GCD using subresultants over a ring. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_rr_prs_gcd(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) r})rr7gcdr{canonical_unitr$rr) rGrHrIresultfcrXgcrrurWrirrs rNdup_rr_prs_gcdrs"!q )F  ! EB ! EB b A!"2&A  DA  &, ''AqQA ! C ! C 3;rPc[XU5nUbU$[XU5Sn[XB5n[XU5n[XU5nXEU4$)a: Computes polynomial GCD using subresultants over a field. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> R.dup_ff_prs_gcd(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) r})rr{r5r)rGrHrIrrWrrs rNdup_ff_prs_gcdrsW"!q )F  !"2&A!A ! C ! C 3;rPcU(d [XU5$[XX#5nUbU$[XU5upV[XU5upx[XhX#5Sn [ XWUS- U5un n [XU5up[ XSX#5n UR [XU55n XR:wa [XX#5n [X X#5n [XX#5nXU4$)aV Computes polynomial GCD using subresultants over a ring. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y >>> R.dmp_rr_prs_gcd(f, g) (x + y, x + y, x) r}rnr) rr dmp_primitiverdmp_rr_prs_gcdrrr&rFrr)rGrHrSrIrrrXrrrWruriunitrrs rNrr s( aA&& q ,F  ! "EB ! "EB!%b)ARQUA.GAq! q !DAQ1a#A  M!2 3D uu} 1A ) ! C ! C 3;rPcNU(d [XU5$[XX#5nUbU$[XU5upV[XU5upx[XhX#5Sn [ XWUS- U5un n [XU5up[ XSX#5n [ XU5n [X X#5n [XX#5n XU 4$)am Computes polynomial GCD using subresultants over a field. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x,y, = ring("x,y", QQ) >>> f = QQ(1,2)*x**2 + x*y + QQ(1,2)*y**2 >>> g = x**2 + x*y >>> R.dmp_ff_prs_gcd(f, g) (x + y, 1/2*x + 1/2*y, x) r}rnr)rrrrdmp_ff_prs_gcdrr6r)rGrHrSrIrrrXrrrWrurirrs rNrr=s( aA&& q ,F  ! "EB ! "EB!%b)ARQUA.GAq! q !DAQ1a#Aq!A ! C ! C 3;rPc|/nU(a2X-nXAS-:aXA-nURSU5 X- U-nU(aM2U$)-Interpolate polynomial GCD from integer GCD. rr)insert)rWxrIrGrHs rN_dup_zz_gcd_interpolaterksG A E Av: FA A UqL ! HrPc[XU5nUbU$[U5n[U5n[XU5up`nUS:XdUS:XaU/X4$[X5n[X5nU"S[ Xx5-S-5n [ [ U SUR U 5-5S[ U[[X55-U[[X55-5-S-5n [S[5GH]n [X U5n [XU5n U (GaU (GaURX5nX-nX-n[XU5n[X5Sn[XU5unnU(d)[XU5unnU(d[!XU5nUUU4s $[XU5n[XU5unnU(d([XU5unnU(d[!XU5nXU4s $[UX5n[UUU5unnU(d)[XU5unnU(d[!XU5nUUU4s $SU -UR UR U 55-S-n GM` [#S 5e) a Heuristic polynomial GCD in `Z[x]`. Given univariate polynomials `f` and `g` in `Z[x]`, returns their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg`` such that:: h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h) The algorithm is purely heuristic which means it may fail to compute the GCD. This will be signaled by raising an exception. In this case you will need to switch to another GCD method. The algorithm computes the polynomial GCD by evaluating polynomials f and g at certain points and computing (fast) integer GCD of those evaluations. The polynomial GCD is recovered from the integer image by interpolation. The final step is to verify if the result is the correct GCD. This gives cofactors as a side effect. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_zz_heu_gcd(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) References ========== .. [1] [Liao95]_ rrcrnB ir)rr!r9rminmaxsqrtabsr$range HEU_GCD_MAXr0rrr7r rr@)rGrHrIrrrrf_normg_normrriffggrWrrcff_rMcfg_s rNdup_zz_heu_gcdr{sFF!q )F  AB ABA!$ICA Qw"'ua{ ! F ! F !C  " $%A C2affQi< c&Cq --Cq --/ /12 3 4A1k " aA  aA  "b A'C'C'a0Aa#A&AaA&GD!!!*a&qq1AdD=()#!4C11%DAq!!*a&qq1A4<')#q4C1c1%DAq!!*a&qq1AdC<' !GaffQVVAY' '5 0Y#\ Y ''rPc/n[X5(dH[XX#5nURSU5 [XX#5n[ XX#5n[X5(dMHUR [ XBS-U55(a[XBS-U5$U$)rrrn)rr4rrr is_negativer&r)rWrrrIrGrHs rN_dmp_zz_gcd_interpolaters A Q1 ( A A!  1 &  }}]1!eQ/00qa%##rPcU(d [XU5$[XX#5nUbU$[XX#5upPn[XU5n[XU5nU"S[ Xg5-S-5n[ [ USUR U5-5S[ U[[XU55-U[[XU55-5-S-5n [S[5GHn [X X#5n [XX#5n US- n [X5(GdM[X5(Gd<[XX5upn[XX5n[XU5Sn[!XX#5unn[UU5(a3[!XX#5unn[UU5(a[#XX#5nUUU4s $[XX5n[!XX#5unn[UU5(a2[!XX#5unn[UU5(a[#XX#5nXU4s $[UXU5n[!UUX#5unn[UU5(a3[!XX#5unn[UU5(a[#XX#5nUUU4s $SU -UR UR U 55-S-n GM [%S 5e) aG Heuristic polynomial GCD in `Z[X]`. Given univariate polynomials `f` and `g` in `Z[X]`, returns their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg`` such that:: h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h) The algorithm is purely heuristic which means it may fail to compute the GCD. This will be signaled by raising an exception. In this case you will need to switch to another GCD method. The algorithm computes the polynomial GCD by evaluating polynomials f and g at certain points and computing (fast) integer GCD of those evaluations. The polynomial GCD is recovered from the integer image by interpolation. The evaluation process reduces f and g variable by variable into a large integer. The final step is to verify if the interpolated polynomial is the correct GCD. This gives cofactors of the input polynomials as a side effect. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y >>> R.dmp_zz_heu_gcd(f, g) (x + y, x + y, x) References ========== .. [1] [Liao95]_ rrrrrrnrrr)rrr:rrrrrr&rrr1rdmp_zz_heu_gcdrr8r rr@)rGrHrSrIrrrrrrrrrrrWrrrrMrs rNrrsP aA&& q ,F  "1.ICA ! "F ! "F !C  " $%A C2affQi< c&C aA 677C aA 6779 9;< = >A1k " aA ! aA ! E2!!Z%6%6(6KAC'a3A$Q1-a0AaA)GD!!Q!!-aa##&qq4AdD=()#!7C11(DAq!Q!!-aa##&qq4A4<')#qQ7C1c1(DAq!Q!!-aa##&qq4AdC<' !GaffQVVAY' '5 0W#Z Y ''rPc[XU5nUbU$UR5n[XU5upP[XU5upa[XU5n[XU5n[ XU5upxn [XtU5n[ Xr5n [ Xr5n[XU5n[XU5n [XRX5U5n[XRX5U5n XxU 4$)a[ Heuristic polynomial GCD in `Q[x]`. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2) >>> g = QQ(1,2)*x**2 + x >>> R.dup_qq_heu_gcd(f, g) (x + 2, 1/2*x + 3/4, 1/2*x) ) rrr,r)rr$r5rro) rGrHrrrrrrWrrrus rNdup_qq_heu_gcdras(!r *F  B QB 'EB QB 'EBA2AA2A r*KACA2Aq A!A cr "C cr "C ffQmR 0C ffQmR 0C 3;rPc[XX#5nUbU$UR5n[XX55up`[XX55upq[XX55n[XX55n[ XX%5upn [XXS5n[ XU5n [ XU5n[XXS5n [XXS5n [XRX5X#5n [XRX5X#5n XU 4$)a] Heuristic polynomial GCD in `Q[X]`. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x,y, = ring("x,y", QQ) >>> f = QQ(1,4)*x**2 + x*y + y**2 >>> g = QQ(1,2)*x**2 + x*y >>> R.dmp_qq_heu_gcd(f, g) (x + 2*y, 1/4*x + 1/2*y, 1/2*x) ) rrr-r*rr&r6rro) rGrHrSrrrrrrWrrrus rNdmp_qq_heu_gcdrs(!q -F  B Q2 *EB Q2 *EBA"!AA"!A q-KACA"!AaBAr"A cb %C cb %C ffQmQ 3C ffQmQ 3C 3;rPcUR(dUR(a`UR5n[ XU5n[ XU5n[ XU5upEn[ XCU5n[ XSU5n[ XcU5nXEU4$UR(a:UR(a[S5(a [XU5$[XU5$UR(a[S5(a [XU5$[XU5$![a UR/X4s$f=f![a Nqf=f![a NGf=f)a? Computes polynomial GCD and cofactors of `f` and `g` in `K[x]`. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_inner_gcd(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) USE_HEU_GCD)is_RRis_CC get_exactrCrFr) dup_inner_gcdrErr>rr@rrrr)rGrHrIexactrWrrs rNrrs+: ww!'' !KKME e $ e $#A%0  ! $#a(#a(s{  77u]++ %aA..aA&& 77u]++ %aA..aA&&9 !EE7A=  !"&  &  s5D6 D'0 D7D$#D$' D43D47 EEchUR(d`UR5n[ XX45n[ XX45n[ XX$5upVn[ XRXC5n[ XbXC5n[ XrXC5nXVU4$UR (a:UR(a[S5(a [XX#5$[XX#5$UR(a[S5(a [XX#5$[XX#5$![a [X#5X4s$f=f![a Nof=f![a NEf=f)z'Helper function for `dmp_inner_gcd()`. r)is_ExactrrCrr*_dmp_inner_gcdrErr>rr@rrrr)rGrHrSrIrrWrrs rNrrs" :: 'KKME a ' a '$Q14  e '#%+#%+s{  77u]++ %aA11aA)) 77u]++ %aA11aA))9 '1=!& & '"&  &  s5C7% D D$7DD D! D!$ D10D1cU(d [XU5$[X4X#5unup[XX#5upVn[XTX#5[XdX#5[XtX#54$)a\ Computes polynomial GCD and cofactors of `f` and `g` in `K[X]`. Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``, and ``cfg = quo(g, h)``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y >>> R.dmp_inner_gcd(f, g) (x + y, x + y, x) )rr'rr()rGrHrSrIJrWrrs rN dmp_inner_gcdr &s`( Q1%%!1&!/IAv q,KAC a #  %  % ''rPc [XU5S$)z Computes polynomial GCD of `f` and `g` in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 r)rrzs rNdup_gcdr Es q !! $$rPc [XX#5S$)z Computes polynomial GCD of `f` and `g` in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y >>> R.dmp_gcd(f, g) x + y r)r rRs rNrrVs" q $Q ''rPcU(aU(d [S5$[X5up0[X5upAURX45n[[ XU5[ XU5U5nUR [Xb55n[XeU-U5$)z Computes polynomial LCM over a ring in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_rr_lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 r) rr7lcmrrr rr$r)rGrHrIrrrurWrSs rN dup_rr_lcmrjs~ A{ ! EB ! EB b Aa a ! %A &A !qS! $$rPcZ[[XU5[XU5U5n[X25$)z Computes polynomial LCM over a field in `K[x]`. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x = ring("x", QQ) >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2) >>> g = QQ(1,2)*x**2 + x >>> R.dup_ff_lcm(f, g) x**3 + 7/2*x**2 + 3*x )rrr r5)rGrHrIrWs rN dup_ff_lcmrs/" a a ! %A Q?rPcTUR(a [XU5$[XU5$)z Computes polynomial LCM of `f` and `g` in `K[x]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 )rErrrzs rNdup_lcmrs% zz!""!""rPc [XU5up@[XU5upQURXE5n[[XX#5[ XX#5X#5n[ XvX#5$)z Computes polynomial LCM over a ring in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y >>> R.dmp_rr_lcm(f, g) x**3 + 2*x**2*y + x*y**2 )r8rrr rr)rGrHrSrIrrrurWs rN dmp_rr_lcmrs[" !q )EB q )EB b Aa#a#Q +A ! %%rPc \[[XX#5[XX#5X#5n[XBU5$)z Computes polynomial LCM over a field in `K[X]`. Examples ======== >>> from sympy.polys import ring, QQ >>> R, x,y, = ring("x,y", QQ) >>> f = QQ(1,4)*x**2 + x*y + y**2 >>> g = QQ(1,2)*x**2 + x*y >>> R.dmp_ff_lcm(f, g) x**3 + 4*x**2*y + 4*x*y**2 )rr rr6)rGrHrSrIrWs rN dmp_ff_lcmrs2" a#a#Q +A A! $$rPczU(d [XU5$UR(a [XX#5$[XX#5$)z Computes polynomial LCM of `f` and `g` in `K[X]`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> f = x**2 + 2*x*y + y**2 >>> g = x**2 + x*y >>> R.dmp_lcm(f, g) x**3 + 2*x**2*y + x*y**2 )rrErrrRs rNdmp_lcmrs5" qQzz!%%!%%rPc[X5US- pC[X5(aU$USSH"n[X5XB5n[X4U5(dM" O UR [ X4U55(a [ X4U5$U$)z Returns GCD of multivariate coefficients. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> R.dmp_content(2*x*y + 6*x + 4*y + 12) 2*y + 6 rnN)r%rrrrr&rrGrSrIcontrrus rNrrsyQlAE!! qrUt% Ta    }}]4A.//t"" rPc [XU5US- pC[X5(d[X4U5(aX04$X0Vs/sHn[XSXB5PM sn4$s snf)z Returns multivariate content and a primitive polynomial. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y, = ring("x,y", ZZ) >>> R.dmp_primitive(2*x*y + 6*x + 4*y + 12) (2*y + 6, x + 2) rn)rrrrrs rNrrsX!"AE!!9Ta00wq:q!wq-q::::sAc[XSX#S9$)z Cancel common factors in a rational function `f/g`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x = ring("x", ZZ) >>> R.dup_cancel(2*x**2 - 2, x**2 - 2*x + 1) (2*x + 2, x - 1) r)include) dmp_cancel)rGrHrIrs rN dup_cancelr!5s aAq 22rPcSnUR(a<UR(a+X3R5p5[XXSSS9up`[XXSSS9upqOURURpg[ XX#5upn Ub.UR Xv5upn[XX55n [XX55n UnUR[XU55n UR[XU55n U (aU (a[XU5[XU5pO+U (aU*[XU5pOU (aU*[XU5pU(dXvX4$[XX#5n [XX#5n X4$)z Cancel common factors in a rational function `f/g`. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> R.dmp_cancel(2*x**2 - 2, x**2 - 2*x + 1) (2*x + 2, x - 1) NT)r) rEhas_assoc_Ringrr-rFr  cofactorsr*rr&rr) rGrHrSrIrrcqcprirrLp_negq_negs rNr r Fs. Bzza&&::sympy.polys.polyerrorsr?r@rArBrCrOrTrZr\r^r`rdrfrjrlrxr{rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrrrr!r rPrNr1sK            %%%%%( F0"60",>0"%P0"%P0"M`/"2)&M`2.%PF R2 : z$+N,B 6#>$ 4*8%P>-`)V   g(T"h(V.b.b<'~!*H'>%"((%<.#(&8%.&4>;,3"2rP