\h jSrSSKJr SSKJr SSKJrJr SSKrSSK J r SSK J r SSK Jr SS KJr SS KJr SS KJr SS KJrJrJr SS KJr SSKJr SSKJrJr SSK J!r!J"r"J#r#J$r$J%r% SSK&J'r' SSK(J)r) SSK*J+r+ SSK,J-r- SSKJ.r.J/r/ SSK0J1r1 "SS\25r3SS.Sjr4Sr5S*Sjr6Sr7S+S,Sjjr8S-S jr9S+S.S!jjr:S+S,S"jjr;S/S#jrS1S&jr?S2S'jr@S(rAS)rBg)3z,Solvers of systems of polynomial equations. ) annotations)Any)SequenceIterableN)Dummy)S)Expr) factor_terms)default_sort_key)Boolean)Polygroebnerroots)ZZ) build_options)parallel_poly_from_exprsqf_part)ComputationFailedPolificationFailedCoercionFailedGeneratorsNeeded DomainError)rcollect) postfixes)cartes) filldedent)OrAnd)Eqc\rSrSrSrSrg) SolveFailed#z.Raised when solver's conditions were not met. N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__r#M/var/www/auris/envauris/lib/python3.13/site-packages/sympy/solvers/polysys.pyr!r!#s8r*r!Fstrictc[U/UQ70UD6upE[U5[UR5s=:XaS:XaJO OGUupx[ SUR 5UR 5-55(a [XxU5$[XEUS9$![an[S[U5U5eSnAff=f![a N>f=f)aH Return a list of solutions for the system of polynomial equations or else None. Parameters ========== seq: a list/tuple/set Listing all the equations that are needed to be solved gens: generators generators of the equations in seq for which we want the solutions strict: a boolean (default is False) if strict is True, NotImplementedError will be raised if the solution is known to be incomplete (which can occur if not all solutions are expressible in radicals) args: Keyword arguments Special options for solving the equations. Returns ======= List[Tuple] a list of tuples with elements being solutions for the symbols in the order they were passed as gens None None is returned when the computed basis contains only the ground. Examples ======== >>> from sympy import solve_poly_system >>> from sympy.abc import x, y >>> solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y) [(0, 0), (2, -sqrt(2)), (2, sqrt(2))] >>> solve_poly_system([x**5 - x + y**3, y**2 - 1], x, y, strict=True) Traceback (most recent call last): ... UnsolvableFactorError solve_poly_systemNc3*# UH oS:*v M g7f)r0Nr#).0is r+ $solve_poly_system..\sA@!Av@r,) rrrlengensall degree_listsolve_biquadraticr! solve_generic) seqr-r8argspolysoptexcfgs r+r/r/'sZD,S@4@4@  5zS]'a' Aq}}@A A A (s33 F 33 D 3SXsCCD  s)B: B8 B5B00B58 CCc[X/5n[U5S:XaUSR(ag[U5S:wa[eURupEUupgUR U5R(d[e[ XdSS9n[U5R5Vs/sHn[X5PM n nURS5n[[U5R55n [R"X5V V s/sHupU RX[5U 4PM n n n [U [ S9$s snfs sn n f) a Solve a system of two bivariate quadratic polynomial equations. Parameters ========== f: a single Expr or Poly First equation g: a single Expr or Poly Second Equation opt: an Options object For specifying keyword arguments and generators Returns ======= List[Tuple] a list of tuples with elements being solutions for the symbols in the order they were passed as gens None None is returned when the computed basis contains only the ground. Examples ======== >>> from sympy import Options, Poly >>> from sympy.abc import x, y >>> from sympy.solvers.polysys import solve_biquadratic >>> NewOption = Options((x, y), {'domain': 'ZZ'}) >>> a = Poly(y**2 - 4 + x, y, x, domain='ZZ') >>> b = Poly(y*2 + 3*x - 7, y, x, domain='ZZ') >>> solve_biquadratic(a, b, NewOption) [(1/3, 3), (41/27, 11/9)] >>> a = Poly(y + x**2 - 3, y, x, domain='ZZ') >>> b = Poly(-y + x - 4, y, x, domain='ZZ') >>> solve_biquadratic(a, b, NewOption) [(7/2 - sqrt(29)/2, -sqrt(29)/2 - 1/2), (sqrt(29)/2 + 7/2, -1/2 + sqrt(29)/2)] rNr0F)expandkey)rr7 is_groundr!r8gcdr rkeysrltrimlist itertoolsproductsubssortedr )rBrCr@Gxypqexprp_rootsq_rootsq_rootp_root solutionss r+r;r;es R !A 1v{qt~~ 1v{ 88DA DA 558   Q% A-21X]]_=_Tx _G=  A58==?#G""74647Ef&++a(&146 )!1 22> 6s #D6D;c^^^^SmSmSUUUU4SjjmT"XRSS9nUb[U[S9$g![a [ef=f) aN Solve a generic system of polynomial equations. Returns all possible solutions over C[x_1, x_2, ..., x_m] of a set F = { f_1, f_2, ..., f_n } of polynomial equations, using Groebner basis approach. For now only zero-dimensional systems are supported, which means F can have at most a finite number of solutions. If the basis contains only the ground, None is returned. The algorithm works by the fact that, supposing G is the basis of F with respect to an elimination order (here lexicographic order is used), G and F generate the same ideal, they have the same set of solutions. By the elimination property, if G is a reduced, zero-dimensional Groebner basis, then there exists an univariate polynomial in G (in its last variable). This can be solved by computing its roots. Substituting all computed roots for the last (eliminated) variable in other elements of G, new polynomial system is generated. Applying the above procedure recursively, a finite number of solutions can be found. The ability of finding all solutions by this procedure depends on the root finding algorithms. If no solutions were found, it means only that roots() failed, but the system is solvable. To overcome this difficulty use numerical algorithms instead. Parameters ========== polys: a list/tuple/set Listing all the polynomial equations that are needed to be solved opt: an Options object For specifying keyword arguments and generators strict: a boolean If strict is True, NotImplementedError will be raised if the solution is known to be incomplete Returns ======= List[Tuple] a list of tuples with elements being solutions for the symbols in the order they were passed as gens None None is returned when the computed basis contains only the ground. References ========== .. [Buchberger01] B. Buchberger, Groebner Bases: A Short Introduction for Systems Theorists, In: R. Moreno-Diaz, B. Buchberger, J.L. Freire, Proceedings of EUROCAST'01, February, 2001 .. [Cox97] D. Cox, J. Little, D. O'Shea, Ideals, Varieties and Algorithms, Springer, Second Edition, 1997, pp. 112 Raises ======== NotImplementedError If the system is not zero-dimensional (does not have a finite number of solutions) UnsolvableFactorError If ``strict`` is True and not all solution components are expressible in radicals Examples ======== >>> from sympy import Poly, Options >>> from sympy.solvers.polysys import solve_generic >>> from sympy.abc import x, y >>> NewOption = Options((x, y), {'domain': 'ZZ'}) >>> a = Poly(x - y + 5, x, y, domain='ZZ') >>> b = Poly(x + y - 3, x, y, domain='ZZ') >>> solve_generic([a, b], NewOption) [(-1, 4)] >>> a = Poly(x - 2*y + 5, x, y, domain='ZZ') >>> b = Poly(2*x - y - 3, x, y, domain='ZZ') >>> solve_generic([a, b], NewOption) [(11/3, 13/3)] >>> a = Poly(x**2 + y, x, y, domain='ZZ') >>> b = Poly(x + y*4, x, y, domain='ZZ') >>> solve_generic([a, b], NewOption) [(0, 0), (1/4, -1/16)] >>> a = Poly(x**5 - x + y**3, x, y, domain='ZZ') >>> b = Poly(y**2 - 1, x, y, domain='ZZ') >>> solve_generic([a, b], NewOption, strict=True) Traceback (most recent call last): ... UnsolvableFactorError c\UR5Hn[USS5(dM g g)z8Returns True if 'f' is univariate in its last variable. NrGFT)monomsany)rBmonoms r+_is_univariate%solve_generic.._is_univariate s)XXZE5": r*crURX05nURU5S:aURSS9nU$)z:Replace generator with a root so that the result is nice. r0F)deep)as_exprdegreerF)rBgenzerorVs r+ _subs_root!solve_generic.._subs_roots7 IIsk " 88C=A e$Ar*cR>[U5[U5s=:XaS:Xa>O O;[[USUSTS9R55nUVs/sHoD4PM sn$[ XSS9n[U5S:XaUSR (a U(d/$g[[ TU55n[U5[U5:a[[S55e[U5S:XaUR5nO[[S55eURnUSn[[URU5TS9R55nU(d/$[U5S:XaUVs/sHoD4PM sn$/n UHhn/n USSn USSH2n T"XU5n U [RLdM!U RU 5 M4 T"X5HnU RX4-5 M Mj U (a/[U S5[U5:wa[[S55eU $s snfs snf) z/Recursively solves reduced polynomial systems. rErrGr,Tr?Nzv only zero-dimensional systems supported (finite number of solutions) )r7rNrrLrrJfilterNotImplementedErrorrpopr8rMrZeroappend)systemr8entryzerosrjbasis univariaterBrir] new_systemnew_gensbeqsolutionrc_solve_reduced_systemrkr-s r+r~,solve_generic.._solve_reduced_systems v;#d) (q (vay$r(6BGGIJE(-.G. .T2 u:?uQx11 &78 u:D !%j2'  z?a  A%j2'  vv2hU1773<7<<>?I u:?(-.G. . DJCRyH3BZ-QVV#%%b)  2*G  G!34H Yq\*c$i7%j2' w/J/s  H( H$T)ruNrHF)r8rrprRr )r?r@r-resultrcr~rks ` @@@r+r<r<sbHAAF"&uhhdCf"233 "!!"s :A c  [X5n[XSS9n[[U55nUR SS5nU(aSnO>UR S5nUb'[ U5HupU R U5XH'M SnUS RS 5US SpJU R5n U"U 5n U(a$U V s1sHo4U RU 54iM nn OU V s1sHo4U 4iM nn [USS 5n[US S5n[UU5GHPunn[5nUGH6unn /[[UU55nnUHn U4U-nU R"U6(dMU RU5S :wdM6U(a*U R U RR!U 55n U RU5R#[%U55nU RU5UR5:XdMUR'U5 M [)US S 9nU"U5n U H3n X;aU RU 5nOU nUR+U 4U-U45 M5 GM9 UnGMS [-SU5[.S 9$s sn fs sn f)a Solve a polynomial system using Gianni-Kalkbrenner algorithm. The algorithm proceeds by computing one Groebner basis in the ground domain and then by iteratively computing polynomial factorizations in appropriately constructed algebraic extensions of the ground domain. Parameters ========== polys: a list/tuple/set Listing all the equations that are needed to be solved gens: generators generators of the equations in polys for which we want the solutions args: Keyword arguments Special options for solving the equations Returns ======= List[Tuple] A List of tuples. Solutions for symbols that satisfy the equations listed in polys Examples ======== >>> from sympy import solve_triangulated >>> from sympy.abc import x, y, z >>> F = [x**2 + y + z - 1, x + y**2 + z - 1, x + y + z**2 - 1] >>> solve_triangulated(F, x, y, z) [(0, 0, 1), (0, 1, 0), (1, 0, 0)] Using extension for algebraic solutions. >>> solve_triangulated(F, x, y, z, extension=True) #doctest: +NORMALIZE_WHITESPACE [(0, 0, 1), (0, 1, 0), (1, 0, 0), (CRootOf(x**2 + 2*x - 1, 0), CRootOf(x**2 + 2*x - 1, 0), CRootOf(x**2 + 2*x - 1, 0)), (CRootOf(x**2 + 2*x - 1, 1), CRootOf(x**2 + 2*x - 1, 1), CRootOf(x**2 + 2*x - 1, 1))] References ========== 1. Patrizia Gianni, Teo Mora, Algebraic Solution of System of Polynomial Equations using Groebner Bases, AAECC-5 on Applied Algebra, Algebraic Algorithms and Error-Correcting Codes, LNCS 356 247--257, 1989 Trn extensionFcXURSSS9VVs/sHupUPM snn$s snnf)NF)multipleradicals) all_roots)rBr_s r+_solve_univariate-solve_triangulated.._solve_univariates+"#++uu+"MN"M$!A"MN NNs&domainNcP[UR5R55$N)rN ground_rootsrL)rBs r+rrs(--/0 0r*rrGrEc"UR5$r)rh)hs r+$solve_triangulated..s QXXZr*rHc3*# UH upUv M g7frr#)r2srs r+r4%solve_triangulated..s+1r6)rrrNreversedget enumerate set_domainrM get_domainalgebraic_fieldrzipset has_only_gensrhrunifyevaldictrsminaddrRr )r?r8r>r@rSrrrr3rCrBdomrvrjr]var_seqvars_seqvarvars _solutionsvaluesHmapping_varsrrVdom_zeros r+solve_triangulatedrisWh  #CD)A Xa[A U+I O"  !! ||F+% 1 Q4::b>1QR5q ,,.C a EFKLedgs22489e L 056gs^ 6tCRy!Gab"H(+ TU $KFCT#dF"34wA ??E**qxx}/A LL)<= ))$w-8Axx} 2 A/0A%a(E "2248H"H& 0(;< #%2 9,: ++1A BBIM6s J$J c [X40UD6nUVs/sHn[U5(aMUPM nnUVVs/sH"ofVs/sHowR5PM snPM$ nnnU$s snfs snfs snnf)a Factorizes a system of polynomial equations into irreducible subsystems. Parameters ========== eqs : list List of expressions to be factored. Each expression is assumed to be equal to zero. gens : list, optional Generator(s) of the polynomial ring. If not provided, all free symbols will be used. **kwargs : dict, optional Same optional arguments taken by ``factor`` Returns ======= list[list[Expr]] A list of lists of expressions, where each sublist represents an irreducible subsystem. When solved, each subsystem gives one component of the solution. Only generic solutions are returned (cases not requiring parameters to be zero). Examples ======== >>> from sympy.solvers.polysys import factor_system, factor_system_cond >>> from sympy.abc import x, y, a, b, c A simple system with multiple solutions: >>> factor_system([x**2 - 1, y - 1]) [[x + 1, y - 1], [x - 1, y - 1]] A system with no solution: >>> factor_system([x, 1]) [] A system where any value of the symbol(s) is a solution: >>> factor_system([x - x, (x + 1)**2 - (x**2 + 2*x + 1)]) [[]] A system with no generic solution: >>> factor_system([a*x*(x-1), b*y, c], [x, y]) [] If c is added to the unknowns then the system has a generic solution: >>> factor_system([a*x*(x-1), b*y, c], [x, y, c]) [[x - 1, y, c], [x, y, c]] Alternatively :func:`factor_system_cond` can be used to get degenerate cases as well: >>> factor_system_cond([a*x*(x-1), b*y, c], [x, y]) [[x - 1, y, c], [x, y, c], [x - 1, b, c], [x, b, c], [y, a, c], [a, b, c]] Each of the above cases is only satisfiable in the degenerate case `c = 0`. The solution set of the original system represented by eqs is the union of the solution sets of the factorized systems. An empty list [] means no generic solution exists. A list containing an empty list [[]] means any value of the symbol(s) is a solution. See Also ======== factor_system_cond : Returns both generic and degenerate solutions factor_system_bool : Returns a Boolean combination representing all solutions sympy.polys.polytools.factor : Factors a polynomial into irreducible factors over the rational numbers )_factor_system_poly_from_expr_is_degeneraterg) eqsr8kwargssystemssyssystems_genericrtrV systems_exprs r+ factor_systemrshh,C@@G&-Igs^C5HsgOI@OPf&1&QYY[&1LP J1Ps A$A$ A.A) A.)A.c&[SU55$)z2Helper function to check if a system is degeneratec38# UHoRv M g7fr)rJr2rVs r+r4!_is_degenerate..9s+Fq{{Fs)ra)rts r+rr7s +F+ ++r*c [X40UD6n[UVVs/sH&n[UVs/sHn[US5PM sn6PM( snn6$s snfs snnf)a Factorizes a system of polynomial equations into irreducible DNF. The system of expressions(eqs) is taken and a Boolean combination of equations is returned that represents the same solution set. The result is in disjunctive normal form (OR of ANDs). Parameters ========== eqs : list List of expressions to be factored. Each expression is assumed to be equal to zero. gens : list, optional Generator(s) of the polynomial ring. If not provided, all free symbols will be used. **kwargs : dict, optional Optional keyword arguments Returns ======= Boolean: A Boolean combination of equations. The result is typically in the form of a conjunction (AND) of a disjunctive normal form with additional conditions. Examples ======== >>> from sympy.solvers.polysys import factor_system_bool >>> from sympy.abc import x, y, a, b, c >>> factor_system_bool([x**2 - 1]) Eq(x - 1, 0) | Eq(x + 1, 0) >>> factor_system_bool([x**2 - 1, y - 1]) (Eq(x - 1, 0) & Eq(y - 1, 0)) | (Eq(x + 1, 0) & Eq(y - 1, 0)) >>> eqs = [a * (x - 1), b] >>> factor_system_bool([a*(x - 1), b]) (Eq(a, 0) & Eq(b, 0)) | (Eq(b, 0) & Eq(x - 1, 0)) >>> factor_system_bool([a*x**2 - a, b*(x + 1), c], [x]) (Eq(c, 0) & Eq(x + 1, 0)) | (Eq(a, 0) & Eq(b, 0) & Eq(c, 0)) | (Eq(b, 0) & Eq(c, 0) & Eq(x - 1, 0)) >>> factor_system_bool([x**2 + 2*x + 1 - (x + 1)**2]) True The result is logically equivalent to the system of equations i.e. eqs. The function returns ``True`` when all values of the symbol(s) is a solution and ``False`` when the system cannot be solved. See Also ======== factor_system : Returns factors and solvability condition separately factor_system_cond : Returns both factors and conditions r)factor_system_condrrr)rr8rrrr|s r+factor_system_boolr<sNB!5f5G 7C7C#.#BbQi#./7C DD.CsA A A A c [X40UD6nUVVs/sH"oDVs/sHoUR5PM snPM$ nnnU$s snfs snnf)a Factorizes a polynomial system into irreducible components and returns both generic and degenerate solutions. Parameters ========== eqs : list List of expressions to be factored. Each expression is assumed to be equal to zero. gens : list, optional Generator(s) of the polynomial ring. If not provided, all free symbols will be used. **kwargs : dict, optional Optional keyword arguments. Returns ======= list[list[Expr]] A list of lists of expressions, where each sublist represents an irreducible subsystem. Includes both generic solutions and degenerate cases requiring equality conditions on parameters. Examples ======== >>> from sympy.solvers.polysys import factor_system_cond >>> from sympy.abc import x, y, a, b, c >>> factor_system_cond([x**2 - 4, a*y, b], [x, y]) [[x + 2, y, b], [x - 2, y, b], [x + 2, a, b], [x - 2, a, b]] >>> factor_system_cond([a*x*(x-1), b*y, c], [x, y]) [[x - 1, y, c], [x, y, c], [x - 1, b, c], [x, b, c], [y, a, c], [a, b, c]] An empty list [] means no solution exists. A list containing an empty list [[]] means any value of the symbol(s) is a solution. See Also ======== factor_system : Returns only generic solutions factor_system_bool : Returns a Boolean combination representing all solutions sympy.polys.polytools.factor : Factors a polynomial into irreducible factors over the rational numbers )rrg)rr8r systems_polyrtrVrs r+rrsHf1EfEL;GH<V,V V,.s15a65r6)rrrr is_Numericalr9factor_system_poly)rr8rr?opts only_numbers_us r+rrs-cCDCFC  15111t9r9 e $$ 0 1 3Z-c4B6B H~**** sAABBc ^ ^ [SU55(d [S5eU(d//$USRm USRm [U U 4SjUSS55(d [ S5e/nUHnUR 5up4UR SLaM&UR S La3U(d/s $URUVVs/sHupVUPM snn5 Mh[[U5R5S5n[UT T S 9nUVVs/sHupVUPM nnnURU5 URU5 M U(d//$[U5n [U 5$s snnfs snnf) aT Factors a system of polynomial equations into irreducible subsystems Core implementation that works directly with Poly instances. Parameters ========== polys : list[Poly] A list of Poly instances to be factored. Returns ======= list[list[Poly]] A list of lists of polynomials, where each sublist represents an irreducible component of the solution. Includes both generic and degenerate cases. Examples ======== >>> from sympy import symbols, Poly, ZZ >>> from sympy.solvers.polysys import factor_system_poly >>> a, b, c, x = symbols('a b c x') >>> p1 = Poly((a - 1)*(x - 2), x, domain=ZZ[a,b,c]) >>> p2 = Poly((b - 3)*(x - 2), x, domain=ZZ[a,b,c]) >>> p3 = Poly(c, x, domain=ZZ[a,b,c]) The equation to be solved for x is ``x - 2 = 0`` provided either of the two conditions on the parameters ``a`` and ``b`` is nonzero and the constant parameter ``c`` should be zero. >>> sys1, sys2 = factor_system_poly([p1, p2, p3]) >>> sys1 [Poly(x - 2, x, domain='ZZ[a,b,c]'), Poly(c, x, domain='ZZ[a,b,c]')] >>> sys2 [Poly(a - 1, x, domain='ZZ[a,b,c]'), Poly(b - 3, x, domain='ZZ[a,b,c]'), Poly(c, x, domain='ZZ[a,b,c]')] An empty list [] when returned means no solution exists. Whereas a list containing an empty list [[]] means any value is a solution. See Also ======== factor_system : Returns only generic solutions factor_system_bool : Returns a Boolean combination representing the solutions factor_system_cond : Returns both generic and degenerate solutions sympy.polys.polytools.factor : Factors a polynomial into irreducible factors over the rational numbers c3B# UHn[U[5v M g7fr) isinstancer )r2polys r+r4%factor_system_poly.. s8%$z$%%%sz(polys should be a list of Poly instancesrc3l># UH)oRT:H=(a URT:Hv M+ g7fr)rr8)r2r base_domain base_genss r+r4rs+[QZ{{k)Ddii9.DDQZs14rENz8All polynomials must have the same domain and generatorsTF)r)r9 TypeErrorrr8r factor_listis_zerorsrr as_coeff_Mulr _factor_sets _sort_systems) r? factor_setsrconstant factors_multrBrconstpfactorsrrrs @@r+rrsZn 8%8 8 8BCC t (//Ka I [QVWXWYQZ[ [ [TUUK!%!1!1!3   t #     &   l;ldal; < X 6 C C Ea HIH(IkBF%12\TQq\G2 NN6 "   w ' t + &F    <3s E. E4c^U(d [51$[U6Vs1sHn[U5iM nnUV^s1sH!m[U4SjU55(aMTiM# sn$s snfs snf)z{ Helper to find the minimal set of factorised subsystems that is equivalent to the original system. The result is in DNF. c3.># UH nTU:v M g7frr#r2s2s1s r+r4$_factor_sets_slow..5s/N+BR+) frozensetrra)rr systems_setrs `r+_factor_sets_slowr+sX  }-3S\:\c9S>\K:$ O2C/N+/N,NB OO; OsA%A*A*c ^U(d [51$[U[S9nUVs/sH o"ULdM UPM nnUVVs/sH nXCVs/sH o$U;dM UPM snU14PM" nnn[5nU(aUR 5upGnU(dUR [U55 M=[U[S9n UVs/sH o"U LdM UPM n nU H4n U Vs/sH o+U;dM UPM n nX1-n UR XU 45 M6 U(aMUV^s1sH!m[U4SjU55(aMTiM# sn$s snfs snfs snnfs snfs snfs snf)z) Helper that builds factor combinations. rHc3.># UH nTU:v M g7frr#rs r+r4_factor_sets..Vs*DVr27Vr)rrr7rrqrrsra)r current_setr other_setsfactorstackrremaining_setscurrent_solutionnext_setnext_remaining next_factorvalid_remaining new_solutionrs `r+rr8sW  }cs#K 9S[$8!SJ9' (&*@*Qaq*@6( K&  (UF 3899;0 0 JJy!12 3 ~3/%3I^7H!^I#K*8Q.Qq {{r"    txx//1 11r*c@[[[[U565$)z!Sort key for lists of polynomials)rNrmapr)rs r+rrfs S-. //r*r)r#)rSequence[Expr | complex]r8Sequence[Expr]rrreturnzlist[list[Expr]])rt list[Poly]rbool)rrr8rrrrr )rrr8rrrrlist[list[Poly]])r?rrr)rz list[list]rzset[frozenset])rzIterable[Iterable[Poly]]rr)Cr( __future__rtypingrcollections.abcrrrOsympyr sympy.corersympy.core.exprr sympy.core.exprtoolsr sympy.core.sortingr sympy.logic.boolalgr sympy.polysr rrsympy.polys.domainsrsympy.polys.polyoptionsrsympy.polys.polytoolsrrsympy.polys.polyerrorsrrrrrsympy.simplifyrsympy.utilitiesrsympy.utilities.iterablesrsympy.utilities.miscrrrsympy.core.relationalr Exceptionr!r/r;r<rrrrrrrrrrrrr#r*r+rs2". -/'--"1C$%,+'$9)9*/;4|@3F~4BqChWt, BEJ5p% %%-;%GJ%%2V!r PFBA 20r*