\h.[SrSSKJr SSKJrJrJrJr SSKJ r SSK J r SSK J r S$SjrS rS rS rS rS rSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!Sr"Sr#Sr$Sr%S r&S!r'S"r(S#r)g)%zGroebner bases algorithms. )Dummy) monomial_mul monomial_lcmmonomial_dividesterm_div)lex) DomainError)queryNcUc [S5n[[S.nX2nUR SpeUR (aUR(d>XRUR5S9pUVs/sHowRU5PM nnU"X5nUb1UV s/sH$oR5SRU5PM& nn U$![a [ SU-5ef=fs snf![a [SU-5ef=fs sn f)aI Computes Groebner basis for a set of polynomials in `K[X]`. Wrapper around the (default) improved Buchberger and the other algorithms for computing Groebner bases. The choice of algorithm can be changed via ``method`` argument or :func:`sympy.polys.polyconfig.setup`, where ``method`` can be either ``buchberger`` or ``f5b``. Ngroebner) buchbergerf5bzO'%s' is not a valid Groebner bases algorithm (valid are 'buchberger' and 'f5b'))domainz'Cannot compute a Groebner basis over %s) r _buchberger_f5bKeyError ValueErrorris_Fieldhas_assoc_Fieldclone get_fieldset_ringr clear_denoms) seqringmethod_groebner_methods _groebnerrorigsGgs Q/var/www/auris/envauris/lib/python3.13/site-packages/sympy/polys/groebnertools.pyr r s~z"" u%- ;;D ??&"8"8 4zz1A1A1CzD$/23cJJt$cC3#A :; =!Qnnq!**40! = H% ujmssttu4 RG&PQ Q R >s#C C-2C(+D  C%-Dc^^^^^^URmURmURmURmUUU4SjnUU4SjnUUUU4SjnT(d/$TSSnUSSm/n[ [ T55HDnTUnUR TSU5nU(dM%URUR55 MF TU:XaOMl0m[5n [5n [5n [T5HuplUTU 'U RU5 M U (aL[U V s/sHn TU PM sn U4SjS9n TU nU RU5 U"XU5upU (aMLSnU (amU"U 5unnU RUU45 [TUTUU5n [U UU4S jS9nU"U U5nU(aU"XUS 5upOUS - nU (aMm[5nU H0nU"TUU U1- 5nU(dMURUS 5 M2 UVs/sHnTUPM nn[UU4S jSS 9nU$s sn fs snf) a Computes Groebner basis for a set of polynomials in `K[X]`. Given a set of multivariate polynomials `F`, finds another set `G`, such that Ideal `F = Ideal G` and `G` is a reduced Groebner basis. The resulting basis is unique and has monic generators if the ground domains is a field. Otherwise the result is non-unique but Groebner bases over e.g. integers can be computed (if the input polynomials are monic). Groebner bases can be used to choose specific generators for a polynomial ideal. Because these bases are unique you can check for ideal equality by comparing the Groebner bases. To see if one polynomial lies in an ideal, divide by the elements in the base and see if the remainder vanishes. They can also be used to solve systems of polynomial equations as, by choosing lexicographic ordering, you can eliminate one variable at a time, provided that the ideal is zero-dimensional (finite number of solutions). Notes ===== Algorithm used: an improved version of Buchberger's algorithm as presented in T. Becker, V. Weispfenning, Groebner Bases: A Computational Approach to Commutative Algebra, Springer, 1993, page 232. References ========== .. [1] [Bose03]_ .. [2] [Giovini91]_ .. [3] [Ajwa95]_ .. [4] [Cox97]_ c(>[UUUU4SjS9nU$)Ncb>T"T"TUSRTUSR55$)NrrLM)pairfrorders r$-_buchberger..select..ds)U<$q' qaz}}+U%Vkey)min)Pprr+rr,s r$select_buchberger..selectasV W r/c>URUVs/sHnTUPM sn5nU(dgUR5nUT;a[T5TU'TRU5 URTU4$s snfN)remmoniclenappendr))r#JjhIr+s r$normal_buchberger..normalgsk EE!%!QAaD!% & Az1v! 441: &sA5cN>^^^TUnURmUR5n[5nU(aUR5nTUnURnT"TU5mUUUUU4SjmT"TU5T:Xd4[ U4SjU55(d,[ U4SjU55(dUR X&45 U(aM[5n U(aRUR5up&TURnT"TU5mT"TU5T:XdU R X&45 U(aMR[5n U(a{UR5upTU Rn TU RnT"X5nT"UT5(aT"U T5U:Xd T"UT5U:XaU R X45 U(aM{X-n [5nU(aGUR5nTURnT"UT5(dUR U5 U(aMGUR U5 UU 4$)NcB>T"TTUR5nT"TU5$r8r()ipmLCMhgr+mh monomial_divrs r$ lcm_divides0_buchberger..update..lcm_dividess$ QrUXX.#E1--r/c34># UH nT"U5v M g7fr8).0ipxrJs r$ ._buchberger..update..s6AS C((Asc3:># UHnT"US5v M g7f)rNrM)rNr4rJs r$rPrQs;2K1..s)r)copysetpopanyadd)r"Bihr?CDigr#mgEB_newig1ig2mg1mg2LCM12G_newrGrJrHr+rIrrs @@@r$update_buchberger..updateus bE TT FFH EB"AB R(E . . B#u,6A666;;;;rh!a$ EUUWFB2B R(EB'50rhauuwHCC&))CC&))C *E r**S"%. b)U2 3*%a  B2BB'' " a  " e|r/NTc(>T"UR5$r8r(r+r,s r$r-_buchberger..s qttr/r0rc.>T"TUR5$r8r()r#r+r,s r$r-rjsU1Q477^r/rc(>T"UR5$r8r(ris r$r-rjs %+r/r1reverse)r,rrIrranger;r9r<r:rT enumeraterWr2removespolysorted)r+rr5rArff1iprFr"CPr?xrYreductions_to_zeror`raG1htGrr\r@rIrrr,s` @@@@@r$rr2sIR JJE$$L$$L$$L EEP   1B  qE s1vA!Aae Aq !'')$  7   A A A B! ! a q!q!1q!'< = qT  qb! ! ":S 3* !C&!C&$ ' A3 4 Ar] 1"Q%(EAr ! #  " B AbE1t8 $ 2 FF2a5M   "B!B%"B  -t v otherwise rrrM)uvr,s r$sig_cmpr0sE tad{tqt| 1;qt $ r/c$US*U"US54$)zt Key for comparing two signatures. s = (m, k), t = (n, l) s < t iff [k > l] or [k == l and m < n] s > t otherwise rrrM)r!r,s r$sig_keyrEsqTE51; r/c:[[USU5US5$)zs Multiply a signature by a monomial. The product of a signature (m, i) and a monomial n is defined as (m * t, i). rr)rr)r!rFs r$sig_multrQs  |AaD!$ad ++r/c[[U5[U5[U5RR5S:aUnOUn[U5[U5- n[ [U5U[ U55$)z Subtract labeled polynomial g from f. The signature and number of the difference of f and g are signature and number of the maximum of f and g, w.r.t. lbp_cmp. r)rrrrr,rr)r+r#max_polyrets r$lbp_subr]s^tAwQq!4!459 (U1X C tH~sCM 22r/c[[[U5US5[U5R U5[ U55$)z Multiply a labeled polynomial with a term. The product of a labeled polynomial (s, p, k) by a monomial is defined as (m * s, m * p, k). r)rrrrmul_termr)r+cxs r$ lbp_mul_termrns5 xQA'q):):2)>A GGr/c[[U5[U5[U5RR5S:Xag[U5[U5:Xa[ U5[ U5:agg)z Compare two labeled polynomials. f < g iff - Sign(f) < Sign(g) or - Sign(f) == Sign(g) and Num(f) > Num(g) f > g otherwise rr)rrrrr,r)r+r#s r$lbp_cmprxsUtAwQq!4!45; Aw$q' q6CF? r/c~[[U5[U5RR5[ U5*4$)z, Key for comparing two labeled polynomials. )rrrrr,rrs r$lbp_keyrs. DGU1X]]00 1CF7 ;;r/c XURn[U5Rn[U5Rn[USUS5UR4n[ XdU5n[ XeU5n[ [[U5[U5R5[U55U5n [ [[U5[U5R5[U55U5n [X5S:Xa[U 5X[U 5Xp4$[U 5Xp[U 5X4$)a Compute the critical pair corresponding to two labeled polynomials. A critical pair is a tuple (um, f, vm, g), where um and vm are terms such that um * f - vm * g is the S-polynomial of f and g (so, wlog assume um * f > vm * g). For performance sake, a critical pair is represented as a tuple (Sign(um * f), um, f, Sign(vm * g), vm, g), since um * f creates a new, relatively expensive object in memory, whereas Sign(um * f) and um are lightweight and f (in the tuple) is a reference to an already existing object in memory. rr) rrLTronerrrr leading_termrr) r+r#rrltfltgltumvmfrgrs r$ critical_pairrs[[F (++C (++C s1vs1v & 3B "6 "B "6 "B c$q'58#8#8#:CFCR HB c$q'58#8#8#:CFCR HBr"R"b211R"b211r/c|[US5RRn[USU[ US55n[USU[ US55n[ X45nUS:XagUS:XaJ[USU[ US55n[USU[ US55n[ Xg5nUS:Xagg)aU Compare two critical pairs c and d. c < d iff - lbp(c[0], _, Num(c[2]) < lbp(d[0], _, Num(d[2])) (this corresponds to um_c * f_c and um_d * f_d) or - lbp(c[0], _, Num(c[2]) >< lbp(d[0], _, Num(d[2])) and lbp(c[3], _, Num(c[5])) < lbp(d[3], _, Num(d[5])) (this corresponds to vm_c * g_c and vm_d * g_d) c > d otherwise rrrr)rrzerorrr)cdrc0d0rwc1d1s r$cp_cmprs 1;   D QqT4QqT #B QqT4QqT #BABwAv 1tS1Y ' 1tS1Y ' BO 7 r/c [[USUR[US555[[USUR[US5554$)z# Key for comparing critical pairs. rrrr)rrrr)rrs r$cp_keyrsP C!diiQqT3 4gc!A$ SVWXYZW[S\>]6^ __r/cZ[[USUS5[USUS55$)zx Compute the S-polynomial of a critical pair. The S-polynomial of a critical pair cp is cp[1] * cp[2] - cp[4] * cp[5]. rrr)rr)cps r$s_polyrs/ <1r!u-|BqE2a5/I JJr/c&UHnUS[U5S:a)[[U5RUS5(a gUS[U5S:XdMXU[ U5:dMi[[U5SUS5(dM g g)a Check if a labeled polynomial is redundant by checking if its signature and number imply rewritability or comparability. (sign, num) is comparable if there exists a labeled polynomial h in B, such that sign[1] (the index) is less than Sign(h)[1] and sign[0] is divisible by the leading monomial of h. (sign, num) is rewritable if there exists a labeled polynomial h in B, such thatsign[1] is equal to Sign(h)[1], num < Num(h) and sign[0] is divisible by Sign(h)[0]. rrTF)rrrr)r)signnumrXr?s r$is_rewritable_or_comparablers 7T!WQZ a T!W55 7d1gaj SV|#DGAJQ88 r/cx[U5RRn[U5RRn[U5(dU$UnUHn[U5(dM[ [U5R [U5R 5(dMN[ [U5R[U5RU5n[[[U5US5[U5U5S:dM[XV5n[X5n O X@:Xd[U5(dU$M)a F5-reduce a labeled polynomial f by B. Continuously searches for non-zero labeled polynomial h in B, such that the leading term lt_h of h divides the leading term lt_f of f and Sign(lt_h * h) < Sign(f). If such a labeled polynomial h is found, f gets replaced by f - lt_f / lt_h * h. If no such h can be found or f is 0, f is no further F5-reducible and f gets returned. A polynomial that is reducible in the usual sense need not be F5-reducible, e.g.: >>> from sympy.polys.groebnertools import lbp, sig, f5_reduce, Polyn >>> from sympy.polys import ring, QQ, lex >>> R, x,y,z = ring("x,y,z", QQ, lex) >>> f = lbp(sig((1, 1, 1), 4), x, 3) >>> g = lbp(sig((0, 0, 0), 2), x, 2) >>> Polyn(f).rem([Polyn(g)]) 0 >>> f5_reduce(f, [g]) (((1, 1, 1), 4), x, 3) r) rrr,rrr)rrrrrrr)r+rXr,rr#r?thps r$ f5_reducers6 !HMM  E 1X]] ! !F 88  AQxx#E!HKKq== qeAhkk6BAxQ16QG!K*!/#AN 6qH r/c f^^TRmUnUn/n[[U55H5nXnURUSU5nU(dM$UR U5 M7 X:XaOMY[[U55Vs/sH,n[ [ TRUS-5XUS-5PM. nnURU4SjSS9 [[U55VVs/sH4n[US-[U55Hn[X#X&T5PM M6 nnnURU4SjSS9 [U5nSn [U5(GaUR5n [U S[U S5U5(aMD[U S [U S 5U5(aMg[U 5n [X5n[ [U5[!U5R#5US-5n[!U5(Ga/n [%U5Houp:[U S[U S5U/5(aU R U5 M:[U S [U S 5U/5(dM^U R U5 Mq ['U 5HnXs M UHzn [!U 5(dM[XMT5n [U S[U S5U/5(aME[U S [U S 5U/5(aMiUR U 5 M| URU4S jSS9 [!U5R(nT"U5T"[!US 5R(5::aUR U5 OL[%U5H=up?T"U5T"[!U5R(5:dM,UR+X45 O US- nOU S- n [U5(aGMUV s/sHn [!U 5R#5PM nn [-UT5n[/UU4S jSS9$s snfs snnfs sn f)a% Computes a reduced Groebner basis for the ideal generated by F. f5b is an implementation of the F5B algorithm by Yao Sun and Dingkang Wang. Similarly to Buchberger's algorithm, the algorithm proceeds by computing critical pairs, computing the S-polynomial, reducing it and adjoining the reduced S-polynomial if it is not 0. Unlike Buchberger's algorithm, each polynomial contains additional information, namely a signature and a number. The signature specifies the path of computation (i.e. from which polynomial in the original basis was it derived and how), the number says when the polynomial was added to the basis. With this information it is (often) possible to decide if an S-polynomial will reduce to 0 and can be discarded. Optimizations include: Reducing the generators before computing a Groebner basis, removing redundant critical pairs when a new polynomial enters the basis and sorting the critical pairs and the current basis. Once a Groebner basis has been found, it gets reduced. References ========== .. [1] Yao Sun, Dingkang Wang: "A New Proof for the Correctness of F5 (F5-Like) Algorithm", https://arxiv.org/abs/1004.0084 (specifically v4) .. [2] Thomas Becker, Volker Weispfenning, Groebner bases: A computational approach to commutative algebra, 1993, p. 203, 216 TNrc:>T"[U5R5$r8)rr)ris r$r-_f5b..qsuQx{{+r/rmc>[UT5$r8rrrs r$r-rus 6"d+r/rrrrc>[UT5$r8rrs r$r-rs 6"d#3r/rc(>T"UR5$r8r(ris r$r-rs 5;r/)r,ror;r9r<rr zero_monomsortrrUrrrrrrr:rpreversedr)insert red_groebnerrs)rxrrXrurvrwr>rykr{rr!indicesr#rFqHr,s ` @r$rr;sD JJE A   s1vAAae Aq  6  AFc!f N 1S!a% (!$A 6 ANFF+TF:49Q= _=a%PQTUPUWZ[\W]J^Q-adD )J^ )=B _GG+TG: AA b'' VVX 'r!uc"Q%j! < <  &r!uc"Q%j! < <  2J aO Qq)1q5 1 88G"2.r!uc"Q%j1#FFNN1%0ABqE QCHHNN1% ' g&E'88&qT2B22a5#be*qcJJ 4RUC1JLL IIbM GG3TG Ba AQx5qu11 %aLDAQx%a "44) FA ! # o b''t$%%1aq 1A%QA !. ==Q O `B &s3P#!;P(##P.c^SnUn/nU(aFUR5m[U4SjX4-55(dURT5 U(aMFU"U5$)z Compute reduced Groebner basis, from BeckerWeispfenning93, p. 216 Selects a subset of generators, that already generate the ideal and computes a reduced Groebner basis for them. c/n[U5H;up#URUSUXS-S-5nU(dM*URU5 M= UVs/sHo3R5PM sn$s snf)z! The actual reduction algorithm. Nr)rpr9r<r:)r3Qrurvr?s r$ reductionred_groebner..reductionsh aLDAaeaAi'(Aq ! $%%1a 1%%%sA-c3d># UH%n[URTR5v M' g7fr8)rr))rNr+f0s r$rPred_groebner..s$@%Q#ADD"%%00%s-0)rUrVr<)r"rrrxrrs @r$rrsS & A A UUW@!%@@@ HHRL ! Q<r/c[[U55HNn[US-[U55H/n[XXU5nURU5nU(dM. g MP g)z! Check if G is a Groebner basis. rFT)ror;rrr9)r"rrur>r!s r$ is_groebnerrs[3q6]q1uc!f%AadAD$'AaAq & r/c4^URmURnURU4SjS9 [U5H]up4URUR :wa gUSUXS-S-H+n[ URUR5(dM* g M_ g)z* Checks if G is a minimal Groebner basis. c(>T"UR5$r8r(r#r,s r$r-is_minimal.. qttr/r0FNrT)r,rrrpLCrrr))r"rrrur#r?r,s @r$ is_minimalrs JJE [[FFF$F%!  446:: 2Aq56"Aadd++#  r/cV^URmURnURU4SjS9 [U5Hnup4URUR :wa gUR 5H9nUSUXS-S-H%n[URUS5(dM# g M; Mp g)z* Checks if G is a reduced Groebner basis. c(>T"UR5$r8r(rs r$r-is_reduced..rr/r0FNrrT) r,rrrprrtermsrr))r"rrrur#termr?r,s @r$ is_reducedrs JJE [[FFF$F%!  446:: GGIDrUQ1uvY&#ADD$q'22 '  r/cURUR:wa [S5eURnURnU(aU(d UR$[ U5S::af[ U5S::aW[ UR UR 5nURURUR5nURXE5$UR5up`UR5upqURXg5nUR5VVs/sH upESU-U4PM n nnUR5VVs/sH upESU-U4PM snnUR5VVs/sH upESU-U*4PM snn-n [S5n URU 4UR-[S9n U R!U 5n U R!U 5n[#X/U 5nSnUVs/sHnU"US5(dMUPM nnUSR5VVs/sHupEUSS XX-4PM nnnUR!U5nU$s snnfs snnfs snnfs snfs snnf) a Computes LCM of two polynomials using Groebner bases. The LCM is computed as the unique generator of the intersection of the two ideals generated by `f` and `g`. The approach is to compute a Groebner basis with respect to lexicographic ordering of `t*f` and `(1 - t)*g`, where `t` is an unrelated variable and then filtering out the solution that does not contain `t`. References ========== .. [1] [Cox97]_ Values should be equalr)r)rr)symbolsr,cT^[U4SjUR555(+$)Nc3,># UH oTv M g7fr8rM)rNmonomr>s r$rP7groebner_lcm..is_independent..As8ZEQxZs)rVmonoms)r?r>s `r$is_independent$groebner_lcm..is_independent@s8QXXZ8888r/rN)rrrrr;rr)lcmrterm_new primitiverrrrr from_termsr )r+r#rrrcoefffcgcrf_termsg_termsrt_ringrxr"basisrr?rh_termss r$ groebner_lcmrs  vv122 66D [[F Ayy 1v{s1v{QTT144( 144&}}U** KKMEB KKMEB **R C:;'')E),%u%)GE:;'')E),%u%)E:;'')E),%uf%)EFG c A ZZt|| 33Z ?F'"A'"A aVV $E94UnQ2!UA4;I 'I$I:IIcURUR:wa [S5eURRnUR(d5UR 5up0UR 5upAUR X45nX-R [X5/5n[U5S:wa [S5eUSnUR(dWU-$UR5$)z6Computes GCD of two polynomials using Groebner bases. rrzLength should be 1r) rrrrr gcdquorr;r:)r+r#rr r rrr?s r$ groebner_gcdrJsvv122 VV]]F ??  jj   <%&'A 1v{-.. !A ??1u wwyr/r8)*__doc__sympy.core.symbolrsympy.polys.monomialsrrrrsympy.polys.orderingsrsympy.polys.polyerrorsr sympy.polys.polyconfigr r rrrrrrrrrrrrrrrrrrrrrrrrrrrrrMr/r$rs!$XX%.(& PRh  (+  *  ,3"H *< 2F! H`K60f}>@@ ((7 rr/