+ iE ^RIHt^RIHt^RIHtHt^RIHt^RI H t ^RI H t ^RI Ht^RIHtHtHt^R IHt^R IHt^R IHtHt^R IHt^R IHt^RIHt^RIH t H!t!^RI"H#t#Rt$RRlt%Rt&Rt'Rt(RR/Rlt)R#))Add) factor_terms) expand_log_mexpand)Pow)S)ordered)Dummy)LambertWexplog)root)roots)Polyfactor) separatevars)collect)powsimp)solve_invert)uniqc8VPUu0uFq!VP9gKVkK pp\V4FXp^V, pW#9gKWC9gKVP4^,\P JdTpVP V4KZ V#uupi)aprocess the generators of ``poly``, returning the set of generators that have ``symbol``. If there are two generators that are inverses of each other, prefer the one that has no denominator. Examples ======== >>> from sympy.solvers.bivariate import _filtered_gens >>> from sympy import Poly, exp >>> from sympy.abc import x >>> _filtered_gens(Poly(x + 1/x + exp(x)), x) {x, exp(x)} )gens free_symbolslistas_numer_denomrOneremove)polysymbolgrags&& w/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/sympy/solvers/bivariate.py_filtered_gensr$s}$yy =y!ann$s BBNcaVPS4Uu.uF[q2'dPVP'dW#P9g.VP'dK@VPV4'gKYVNK] pp\ V4^8Xd V^,#V'd$\ \ \V44V3RlR7#R#uupi)aReturns the term in lhs which contains the most of the func-type things e.g. log(log(x)) wins over log(x) if both terms appear. ``func`` can be a function (exp, log, etc...) or any other SymPy object, like Pow. If ``X`` is not ``None``, then the function returns the term composed with the most ``func`` having the specified variable. Examples ======== >>> from sympy.solvers.bivariate import _mostfunc >>> from sympy import exp >>> from sympy.abc import x, y >>> _mostfunc(exp(x) + exp(exp(x) + 2), exp) exp(exp(x) + 2) >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp) exp(exp(y) + 2) >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp, x) exp(x) >>> _mostfunc(x, exp, x) is None True >>> _mostfunc(exp(x) + exp(x*y), exp, x) exp(x) c&<VPS4#N)count)xfuncs&r#_mostfunc..Ps  )keyN)atoms is_Symbolrhaslenmaxrr )lhsr*Xtmpftermss&f& r# _mostfuncr8/s6!YYt_)_cQ --- KKGGAJc_F) 6{aay 4(.EFF )sB>B>B>0B>c\VP44pVPV4wr#VP'd2VP'd \ W14wrEpW$,W%,V3#VP'g^pY#rdM Tp\ V4PVRR7wrFVP4'dV)pV)pWEV3#)aReturn ``a, b, X`` assuming ``arg`` can be written as ``a*X + b`` where ``X`` is a symbol-dependent factor and ``a`` and ``b`` are independent of ``symbol``. Examples ======== >>> from sympy.solvers.bivariate import _linab >>> from sympy.abc import x, y >>> from sympy import exp, S >>> _linab(S(2), x) (2, 0, 1) >>> _linab(2*x, x) (2, 0, x) >>> _linab(y + y*x + 2*x, x) (y + 2, y, x) >>> _linab(3 + 2*exp(x), x) (2, 3, exp(x)) Fas_Add)rexpandas_independentis_Mulis_Add_linabrcould_extract_minus_sign)argr inddepabr)s&& r#r@r@Ts( szz| $C!!&)HC zzzcjjj%auceQ ::: 1 C //u/E!!## B B 7Nr-c6aa\\V44p\V\V4pV'g.#VP V^4p\ V)\4'dqW, P W"P ^,4pVP ^,p\ V\4'g.#V)P ^,)pW, pWP9d.#\W14wrEp\W, V4pVPV4pVeWP9d.#VP ^,p \W4wrp W8wd.#\R4o\V S, V4p R^.p.pW,W,, V, V , P4wppVP4wpp\VV, 4p\R4p\!VV,V, V4P#4Uu.uFpWHV ,, V,NK ppVFnpVFep\%VV4pV'dVP&'gK+V )V , W, V,,oVP)VV3RlV 44Kg Kp V#uupi)z Given an expression assumed to be in the form ``F(X, a..f) = a*log(b*X + c) + d*X + f = 0`` where X = g(x) and x = g^-1(X), return the Lambert solution, ``x = g^-1(-c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(-f/a)))``. rhstc3F<"TFqPSS4xK R#5ir')subs).0xurHus& r# _lambert..s92wwq#s!)rrr8r rK isinstanceargsrr@ras_coefficientr rr as_coeff_Mulr rkeysr is_realextend)eqr)mainlogotherdfX2logtermrElogargrFcX1xusolnslambert_real_branchessolnumdenperIrSrBkwrHrNs&& @@r#_lambertrlys% *R. !BC#G  GGGQ E5&#j  w Q 8,,q/'3''I&q!! """ eHA"bj'*Gw'AyA' \\!_Ff HA" x  e ABFAG G CQS! A --/HC    FAs CG A c A$QTAXq1668 98!AsGAII8D 9&Aa A"Q$!#q.C JJ99 9 ' J :s?Jc@ aaaV3RlpVPSRR7wrEV)pSUu.uFQpVP\\39g2VP'gK2SVPP 9gKOVNKS ppV'g \ 4hVP'gVP'Ed\R /SPBoVPV3RlV3Rl4pVP'dVPS4'dVPS^4p WY, p Wi, p V P'gkV 'dcV P\P\P 4'g/\#\V 4\V 4, 4p V!V SS4#MvVP'deV'd]\#\V4RR7p\V4pVPS4'd%VP'dWV, p V!V SS4#VP%SS/4p\'\)VRR74p\4p \+W], S4wrVP%W/4p.pV'EgR\-V\S4pV'Ed8VP'd.V^8wd'\/\V4\V4, S4pMVP'dVPV^4pV'dVP'gVP1\24Uu.uFpSVP 9gKVNK up'dkV'g$\V4\VV, 4, pM)\VV, 4\VV, 4, p\/\#V4S4pM\/WV, S4pV'Eg\-V\S4pV'd\5VV4pVP'd7V^8wd0\/\#\V4\V4, 4S4pMVP'dVPV^4pVV, pVV, pVP74'd)VP74'dVR ,pVR ,p\V4\V4, p\/\#V4S4pV'g\-V\2S4pV'dSVPP 9d\5VV4pVP'd7V^8wd0\/\#\V4\V4, 4S4pMfVP'dUVPV^4pVV, pVV, p\V4\V4, p\/\#V4S4pV'g\ RV,4h\9\;V44#uupiuupi) apReturn solution to ``f`` if it is a Lambert-type expression else raise NotImplementedError. For ``f(X, a..f) = a*log(b*X + c) + d*X - f = 0`` the solution for ``X`` is ``X = -c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(f/a))``. There are a variety of forms for `f(X, a..f)` as enumerated below: 1a1) if B**B = R for R not in [0, 1] (since those cases would already be solved before getting here) then log of both sides gives log(B) + log(log(B)) = log(log(R)) and X = log(B), a = 1, b = 1, c = 0, d = 1, f = log(log(R)) 1a2) if B*(b*log(B) + c)**a = R then log of both sides gives log(B) + a*log(b*log(B) + c) = log(R) and X = log(B), d=1, f=log(R) 1b) if a*log(b*B + c) + d*B = R and X = B, f = R 2a) if (b*B + c)*exp(d*B + g) = R then log of both sides gives log(b*B + c) + d*B + g = log(R) and X = B, a = 1, f = log(R) - g 2b) if g*exp(d*B + h) - b*B = c then the log form is log(g) + d*B + h - log(b*B + c) = 0 and X = B, a = -1, f = -h - log(g) 3) if d*p**(a*B + g) - b*B = c then the log form is log(d) + (a*B + g)*log(p) - log(b*B + c) = 0 and X = B, a = -1, d = a*log(p), f = -log(d) - g*log(p) c<RUu.uFq0PWV,/4NK upwrE\WBS4pWT8wdVP\WRS44\\ V44#uupi)aReturn the unique solutions of equations derived from ``expr`` by replacing ``t`` with ``+/- symbol``. Parameters ========== expr : Expr The expression which includes a dummy variable t to be replaced with +symbol and -symbol. symbol : Symbol The symbol for which a solution is being sought. Returns ======= List of unique solution of the two equations generated by replacing ``t`` with positive and negative ``symbol``. Notes ===== If ``expr = 2*log(t) + x/2` then solutions for ``2*log(x) + x/2 = 0`` and ``2*log(-x) + x/2 = 0`` are returned by this function. Though this may seem counter-intuitive, one must note that the ``expr`` being solved here has been derived from a different expression. For an expression like ``eq = x**2*g(x) = 1``, if we take the log of both sides we obtain ``log(x**2) + log(g(x)) = 0``. If x is positive then this simplifies to ``2*log(x) + log(g(x)) = 0``; the Lambert-solving routines will return solutions for this, but we must also consider the solutions for ``2*log(-x) + log(g(x))`` since those must also be a solution of ``eq`` which has the same value when the ``x`` in ``x**2`` is negated. If `g(x)` does not have even powers of symbol then we do not want to replace the ``x`` there with ``-x``. So the role of the ``t`` in the expression received by this function is to mark where ``+/-x`` should be inserted before obtaining the Lambert solutions. )rQ)xreplace_solve_lambertrXrr)exprrIr sgnnlhsplhssolsrs&&& r#_solve_even_degree_expr/_solve_lambert.._solve_even_degree_exprshV7>?6=sMM1&j/ *g? dD1 < KKtT: ; DJ?s!A-Tr:c<VP;'d.VPS8H;'dVPP#r')is_Powbaser is_even)ir s&r#r+ _solve_lambert..(s.??QVVv-??!%%--?r-c*<SVP,#r')r )r}rIs&r#r+r~*s155r-)force)deepz:%s does not appear to have a solution in terms of LambertW)rIrQ)r=r*r r rzrNotImplementedErrorr?r>r assumptions0replacer1rKrComplexInfinityNaNrrprrrr8rlr/rrrArr )r]r rrwnrhsr4rHr6lamcheckt_indept_term_rhsrYrr}solnrZr[diffmainexpmaintermmainpowrIs&ff @r#rqrqsD4 l   5ID %C#BtHHc * &#''*>*> >tHB !## zzzSZZZ  -,, -kk @  :::#''!**hhq!nG]F=D===TJJq00!%%88F c$i 78.r1f== ZZZCSXT2Cc(CwwqzzcjjjY.r1f==llAv;' &4( )C A SWf %FA **aX C D 4Cf- 7zzzcQhC3s8 3V<!,',{{3'737'7!S%5%55'73737"5zC ,<<"3;/#cEk2BB#Jt$4f=D$CIv6D 4Cf- #w'CzzzcQh 3s8c#h+> ?H!,;Ek55770022NH2IC8}s3x/ 4 0&9 Cf- v!9!99#w'CzzzcQh 3s8c#h+> ?H!,;Ek8}s3x/ 4 0&9 !# "##$% %  EB@37s/XX7X5X XfirstTc aa\RRR7pV'd\VSS4pVP4p\4p\4p\\VP SVSV/4Wg4WgRR7pV'd?VSVS/p V^,P V 4V^,P V 4V^,3#R#TpVP4p\ P!VP44p .p V FRp \V P SVS, 44p V Pp SV 9gSV 9dM(V PV 4KT SS,\ V !V3#VV3Rlp.p VPS4pVPS4V8Xd\VPSV,4V4p \VPSV,4V4pV!VSVVS,, V , 4p V eV S,VS,,W3#.p VPS4pVPS4V8Xd\^4Fp\VPSV,SV,,4V4p \VPSV,4V4pV!VSVVS,, V , S, 4p V e#V S,S,VS,,W3u#SSuooK R#R#)aoGiven an expression, f, 3 tests will be done to see what type of composite bivariate it might be, options for u(x, y) are:: x*y x+y x*y+x x*y+y If it matches one of these types, ``u(x, y)``, ``P(u)`` and dummy variable ``u`` will be returned. Solving ``P(u)`` for ``u`` and equating the solutions to ``u(x, y)`` and then solving for ``x`` or ``y`` is equivalent to solving the original expression for ``x`` or ``y``. If ``x`` and ``y`` represent two functions in the same variable, e.g. ``x = g(t)`` and ``y = h(t)``, then if ``u(x, y) - p`` can be solved for ``t`` then these represent the solutions to ``P(u) = 0`` when ``p`` are the solutions of ``P(u) = 0``. Only positive values of ``u`` are considered. Examples ======== >>> from sympy import solve >>> from sympy.solvers.bivariate import bivariate_type >>> from sympy.abc import x, y >>> eq = (x**2 - 3).subs(x, x + y) >>> bivariate_type(eq, x, y) (x + y, _u**2 - 3, _u) >>> uxy, pu, u = _ >>> usol = solve(pu, u); usol [sqrt(3)] >>> [solve(uxy - s) for s in solve(pu, u)] [[{x: -y + sqrt(3)}]] >>> all(eq.subs(s).equals(0) for sol in _ for s in sol) True rNT)positiveF)rNct<\VPW44pVPpSV9gSV9dR#T#r')rrKr)r]vranewfreer)ys&&& r#okbivariate_type..oks7qvva|$T Q$Yt8S8r-)r ras_exprbivariate_typerKrpr make_argsrrappenddegreercoeff_monomialrange)r]r)rrrNrh_x_yrvrepsrSrrErrr\rFitrys&ff$ r#rrs{N cD!A AqM IIK W W DB2!7@"PU V 2q>Da5>>$'A)=r!uD D A A == %D C  QVVAqs^ $~~ 9T  1 sCIq  9 C  Axx{a !!!Q$' + !!!Q$' +AAaC{# ?Q319c$ $ C  Axx{a!HDQ%%ad1a4i0!4AQ%%ad+Q/AQA!GQ;q=)Cs1uqs{C**aDAq r-r')*sympy.core.addrsympy.core.exprtoolsrsympy.core.functionrrsympy.core.powerrsympy.core.singletonrsympy.core.sortingr sympy.core.symbolr &sympy.functions.elementary.exponentialr r r (sympy.functions.elementary.miscellaneousrsympy.polys.polyrootsrsympy.polys.polytoolsrrsympy.simplify.simplifyrsympy.simplify.radsimprrsympy.solvers.solversrrsympy.utilities.iterablesrr$r8r@rlrqrr-r#rse-4 "&#GG9'.0*+0*8"J"JEP]@\T\r-