\hP.SrSSKJr SSKJrJrJrJrJrJ r J r J r J r SSK Jr SSKJrJrJrJrJrJrJr SSKJr SSKJrJrJrJr SSKJr SS K J!r!J"r"J#r# SS K$J%r%J&r& SS K'J(r(J)r) SS KJ*r* SS K+J,r, SSK-J.r/J0r1 SSK2J3r3 SSK4J5r5 SSK6J7r7J8r8J9r9J:r: SSK;JJ?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrN SSKOJPrP SSKQJRrRJSrSJTrTJUrU SSKVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrbJcrc SSKdJere SSKfJgrg SSKhJiriJjrj SSKkJlrlJmrmJnrnJoroJprpJqrqJrrrJsrsJtrt SSKuJvrvJwrw SSKxJyryJzrzJ{r{ SSK|J}r} SSK~JrJr SSKJrJrJrJrJrJrJrJ0r0J.r. SS KJr SS!KJrJrJr SS"KJrJrJr SS#K2Jr SS$KJrJrJrJrJr SS%KJr SS&KJr SS'KJrJrJrJr SS(KJrJrJr SS)KJr "S*S+\5rS,r\GRX4S-jr\rS.rS/rS0qS0qS1rS2rS3rS4rS5rS6r\GRX4S7jrS8rS9r"S:S;\5rS<rS=rS>r\GRX4S?jrS@rSArSBrS`SDjrSErSFrSGrSHrSIrSJrSKrSLrSMrSNrS0\GRX4SOjrSPrSQrSRrSSrSCST.SUjrSVrSWrSXr0///S04SYjrSZrS[rS\rS]rS^rS_rg0)aa This module contains functions to: - solve a single equation for a single variable, in any domain either real or complex. - solve a single transcendental equation for a single variable in any domain either real or complex. (currently supports solving in real domain only) - solve a system of linear equations with N variables and M equations. - solve a system of Non Linear Equations with N variables and M equations )sympify) SPowDummypiExprWildMulAddBasic)Tuple)Lambdaexpand_complex AppliedUndef expand_log_mexpand expand_trignfloat)Mod)INumberRationaloo) integer_log)EqNe Relational)default_sort_keyordered)Symbol_uniquely_named_symbol)_sympify)preorder_traversal)gcdlcm)_linear_eq_to_dict)UnsolvableFactorError)simplifyfractiontrigsimp nsimplify) powdenest logcombine)logtancotsincosseccscexpacosasinatanacotacscasecpiecewise_fold Piecewise)totient)Absargreim) HyperbolicFunctionsinhcoshtanhcothsechcschasinhacoshatanhacothasechacsch) real_root)TrigonometricFunction)And BooleanTrue) FiniteSetimagesetInterval IntersectionUnion ConditionSetImageSet ComplementContains)Set ProductSet)zerosMatrix MatrixBase)divisors) discrete_log nthroot_mod) rootsPolydegreetogetherPolynomialErrorRootOffactorr%r$)CoercionFailed)invertgroebnerpoly)sympy_eqs_to_ring solve_lin_sysPolyNonlinearError) _linsolve)checksoldenomsunrad _simple_densrecast_to_symbols)solve_poly_system) filldedent)numbered_symbolshas_dups is_sequenceiterable) periodicitycontinuous_domainfunction_range) GeneratorTypec\rSrSrSrSrg)NonlinearErrorDz9Raised when unexpectedly encountering nonlinear equationsN__name__ __module__ __qualname____firstlineno____doc____static_attributes__rN/var/www/auris/envauris/lib/python3.13/site-packages/sympy/solvers/solveset.pyrrDsCrrcR[S[SS9n/n[UR"U65H7nUHnUR"U6nM UR U[ U545 M9 [U5HunupgUR Xg5nXv4X5'M [[U55nX4$)aReturn ``f``, with all objects given by ``atoms`` replaced with Dummy symbols, ``d``, and the list of replacements, ``(d, e)``, where ``e`` is an object of type given by ``atoms`` in which any other instances of atoms have been recursively replaced with Dummy symbols, too. The tuples are ordered so that if they are applied in sequence, the origin ``f`` will be restored. Examples ======== >>> from sympy import cos >>> from sympy.abc import x >>> from sympy.solvers.solveset import _masked >>> f = cos(cos(x) + 1) >>> f, reps = _masked(cos(1 + cos(x)), cos) >>> f _a1 >>> reps [(_a1, cos(_a0 + 1)), (_a0, cos(x))] >>> for d, e in reps: ... f = f.xreplace({d: e}) >>> f cos(cos(x) + 1) aT)clsreal) r{rratomsreplaceappendnext enumeratelistreversed)frsymmaskrions r_maskedrIs4 3E 5C D QWWe_ %A 1 A QS N#&t_ 6A IIaO&%  D 7Nrch[U5nUR(d [S5e[U5nX R;a [S5e[U5nX!R;a [S5eUR [ R 5(a[U[U5U5upEO[U[U5U5upEXB:waXE4$U[ RLaXE4$[U[5(aXERU54$U[ R LaXE4$XERU54$)ak Reduce the complex valued equation $f(x) = y$ to a set of equations $$\left\{g(x) = h_1(y),\ g(x) = h_2(y),\ \dots,\ g(x) = h_n(y) \right\}$$ where $g(x)$ is a simpler function than $f(x)$. The return value is a tuple $(g(x), \mathrm{set}_h)$, where $g(x)$ is a function of $x$ and $\mathrm{set}_h$ is the set of function $\left\{h_1(y), h_2(y), \dots, h_n(y)\right\}$. Here, $y$ is not necessarily a symbol. $\mathrm{set}_h$ contains the functions, along with the information about the domain in which they are valid, through set operations. For instance, if :math:`y = |x| - n` is inverted in the real domain, then $\mathrm{set}_h$ is not simply $\{-n, n\}$ as the nature of `n` is unknown; rather, it is: $$ \left(\left[0, \infty\right) \cap \left\{n\right\}\right) \cup \left(\left(-\infty, 0\right] \cap \left\{- n\right\}\right)$$ By default, the complex domain is used which means that inverting even seemingly simple functions like $\exp(x)$ will give very different results from those obtained in the real domain. (In the case of $\exp(x)$, the inversion via $\log$ is multi-valued in the complex domain, having infinitely many branches.) If you are working with real values only (or you are not sure which function to use) you should probably set the domain to ``S.Reals`` (or use ``invert_real`` which does that automatically). Examples ======== >>> from sympy.solvers.solveset import invert_complex, invert_real >>> from sympy.abc import x, y >>> from sympy import exp When does exp(x) == y? >>> invert_complex(exp(x), y, x) (x, ImageSet(Lambda(_n, I*(2*_n*pi + arg(y)) + log(Abs(y))), Integers)) >>> invert_real(exp(x), y, x) (x, Intersection({log(y)}, Reals)) When does exp(x) == 1? >>> invert_complex(exp(x), 1, x) (x, ImageSet(Lambda(_n, 2*_n*I*pi), Integers)) >>> invert_real(exp(x), 1, x) (x, {0}) See Also ======== invert_real, invert_complex zx must be a symbolz*Inverse of constant function doesn't existzy should be independent of x ) r is_Symbol ValueError free_symbols is_subsetrReals _invert_realrT_invert_complex Complexes isinstance intersect)f_xyxdomainx1ss r_invertrps p  A ;;-.. #,C   EFF ANN899   S)A,2AYq\15 u u !Y;;v&&&u ;;v&&&rc8[XU[R5$)zv Inverts a real-valued function. Same as :func:`invert_complex`, but sets the domain to ``S.Reals`` before inverting. )rrr)rrrs r invert_realrs 31agg &&rc X:XdU[RLaX!4$[SSS9n[U[5(d/UR (aRUR [R:Xa4[UR[[U[U55U5U5$[US5(aUR5b[U[[45(de[!UR"5S:a [%S5e[UR"S[[X0R5"U55U5U5$[U[&5(a[)UR"SX5$UR*(aIUR-U5upEU[R.La#[U[[X3U- 5U5U5$UR0(aIUR-U5upEU[R2La#[U[[X3U- 5U5U5$UR (GaUR"upgUR5U5nUR5U5n U (GdHUR6(aUR95upU S-S:Xa^U S-S:XaUU R:S LaF[U[=X755n U[?S[@5-n [X5n[XnU5unnUU4$U S-S:Xac[U[=X755n [X5nU S-S:Xa%[[X3*5U5n[XnU-U5$U S-S:Xa [XnU5$OQURB(a?[U[=X755n U[?S[@5-n [X5n[XnU5$U(GdUR"SnURD(a)[U[[U[X6S S 95U5U5$URF(a>[IUU5unnU(a[U[KU5U5$U[R4$UR:(a\[MUS5nU[RN:Xa[U[KS5U5$U[RP:XaU[R4$[U[[45(a [SXU5$X4$) Helper function for _invert.rTrinverse/Only functions with one argument are supported.rFevaluate)*rEmptySetrrr5is_PowbaseExp1rrUrr.hasattrrrQrClenargsrr? _invert_absis_Addas_independentZerois_MulOnehas is_rationalas_numer_denomis_zerorPrVr is_irrational is_positive is_negativerrTrtruefalse_invert_trig_hyp_real)rg_yssymbolrghrexpo base_has_sym expo_has_symnumdenrootg_ys_posres_inv_setneg_resrhsrbones rrrs {dajj(~ cA!Sahh166QVV+;AEE$VAs1v%6="$ $q)!8A ! PBB qvv;?NO OAFF1I$VAyy{1~%>E"$ $!S166!9d33xx' AFF?8F1!e,8F1cND#A6J JxxxVV xx' xx' ..07a+D-HHQw!|+Dv>>##a1!34(1b/1t.#Dv66 ))A,C#DVAs1U'CDdKVUU!!"3-1'ilFCC !**--aj!&&='ilFCCAGG^ !**--!+-?@AA$Qf55 9rNc ^^^^ ^ ^ [T[5(GaX[SSS9m [T[5(a.[ TR S[ T [T 5U5T5$[T[5(aUR[S[55n[U[5(a[U[5(aUnOTU4$[ TR S[[ T [T 5U5[ T [T 5*U55T5$[T[ 5(aUR[R""SS55n[U[5(a[U[5(aUnOTU4$[ TR S[[ T [%T 5U5[ T [%T 5*U55T5$[T[&5(aUR[R("SS55n[U[5(a[U[5(aUnOTU4$[ TR S[ T [+T 5U5T5$[T[,5(anU[SS5- n[U[.5(a[U[5(aUnOTU4$[ TR S[ T [1T 5U5T5$[T[25(amU[S5- n[U[.5(a[U[5(aUnOTU4$[ TR S[ T [5T 5U5T5$g [T[65(ae[U[5(aPSnU"TR85umm m [SSS9m UUU U U U4S jn[UVs/sH oe"U5PM sn6nTU4$TU4$s snf) aUHelper function for inverting trigonometric and hyperbolic functions. This helper only handles inversion over the reals. For trigonometric functions only finite `g_ys` sets are implemented. For hyperbolic functions the set `g_ys` is checked against the domain of the respective inverse functions. Infinite `g_ys` sets are also supported. rTrrrc$[Gc[[S4S[-[ SS54[ [ S4S[-[ SS54[[4[[R4[[4[[R4[[S4S[-[[ [ *S5[ S[ 554["[$S4S[-[[ [ *S5[ S[ 5540q[U$)Nc&[[U5- $N)rr7rs rC_invert_trig_hyp_real.._get_trig_inverses.. BtAwJrrrrc[U5*$r)r6rs rrr T!WHrc[U5*$r)r;rs rrrrrc&[[U5- $r)rr:rs rrrrr)_trig_inversesr1r7rrVr2r6r/r8rrr0r9r3r;rXrr4r:funcs r_get_trig_inverses1_invert_trig_hyp_real.._get_trig_inversess%D"672xAOD"45qtXb!_MD7B0D7B0D"45qthsB/!RACD"672hsB/!RAC"D"$' 'rintegerc R>[TVs/sH*n[TT T-U"U5-[R5PM, sn6n[ TR SUT 5up4UT :XaT R U5n[T XT5$[T [TU5[R5$s snfNr) rXrUrIntegersrrcontainsrYrr) rinvinvsimginv_finv_g_yscondsrinvsrperiodrngrs rcreate_return_set0_invert_trig_hyp_real..create_return_setsFJLFJsF1Hs1v-qzz:dLMG*166!9gvFOE Q#FE<<#FBq!Hagg>>Ls1B$N)rrCrrDrrrUrJrErrVrrWrTrXrKrHLopenrNrFopenrLrGr[rMrIrOrQr) rrrg_ys_domrrrretsetrrrrs ` ` @@@@rrrMs]!'(( #D ! a  q 8AuQx+FO O a  ~~hq"o6H(L11dI.. $Ht9$q 5E!Hh/U1XIx0,239; ; a  ~~hnnQ&:;H(L11dI..#Ht9$q 5E!Hh/U1XIx0,239; ; a  ~~hmmB&:;H(L11dI..#Ht9$q E!Hh/9 9 a  hr1o-H(J//dI..#Ht9$q E!Hh/9 9 a  il*H(J//dI..#Ht9$q E!Hh/9 9  A, - -*T92M2M (/qvv6fc #t $ ? ?tHelper function for inverting trigonometric and hyperbolic functions. This helper only handles inversion over the complex numbers. Only finite `g_ys` sets are implemented. Handling of singularities is only implemented for hyperbolic equations. In case of a symbolic element g in g_ys a ConditionSet may be returned. cx>^^[T[[45(a/[T[5(a[O[mUU4SjUU4Sj4$[T[ [ 45(a/[T[ 5(a[O[mUU4SjUU4Sj4$[T[[45(aUU4Sj4$g)Nc.>ST-[-T"U5-$NrrrFrs rr7_invert_trig_hyp_complex..inv..ac"fqtmrc<>ST-[-[-T"U5- $rrrs rrrsac"frkAaD0rc.>ST-[-T"U5-$rrrs rrrrrc.>ST-[-T"U5- $rrrs rrrrrcD>T[-TR5"U5-$r)rr)rrtrigs rrrs!B$):":r) rr1r4r7r:r2r3r6r;r/r0)rrrs`@rr%_invert_trig_hyp_complex..invs$c ++&tS11Dt+022$c ++&tS11Dt++--$c ++:<<,rrTrrcz[c[[S4S[-[-S4[ [ S4S[-[-S4[[4[[-S4[[4[[-S4[[S4S[-[-S4[[S4S[-[-S40q[U$) Nc4[[-[U5- $r)rrrJrs rrE_invert_trig_hyp_complex.._get_hyp_inverses..ad58mrrrc[U5*$r)rKrs rrr uQxir)rrc[U5*$r)rNrs rrrr"r)rc4[[-[U5- $r)rrrOrs rrrr r) _hyp_inversesrDrJrrrErKrFrLrGrMrHrNrIrOrs r_get_hyp_inverses3_invert_trig_hyp_complex.._get_hyp_inversess$U$;[T Vs/sH*n[T T T -U"U5-[R5PM, sn6n[ TR SUT 5up4UT :Xa.[ TVs/sHn[X5PM sn6n[T Xd5$[T [TU5[R5$s snfs snfr) rXrUrrrrrRrrYrr) rrrrrerexclrrrrrs rr3_invert_trig_hyp_complex..create_return_setsFJLFJsF1Hs1v-qzz:dLMG-affQi&IOE51bh56#FE<<#FBq!HakkBBL6s 1B5+B:)rrQrTrrrrXrUrrrrrCr) rrrrLrr&rr r*rrrs ` ` @@@@r_invert_trig_hyp_complexr-s&!*++ 40K0K = #t $zzQA E4P4aHVAqt_ajjA4PQ QDqvvay$77 A) * *z$ /J/J '/qvv6fd #t $ C CtnUR<R@n [SRC[3U 555n U 4U -n [E[[U 4[FSU -[H-[KU5--[M[OU55-5[RP[3U 5-5/6n [ UR0X5$[+U["5(a[EUV s/sH`oS:wdM [[U[FSU-[H-[KU 5--[M[OU 55-5[RP5PMb sn 6n [ UR0X5$[+U[,[.45(a [SXU5$X4$s sn f)rrrrrrzk{}r)*rrrrrrrrUrrrNegativeInfinityComplexInfinityInfinityrr is_RationalrTrrrrrQrCr5rrrrrZlamdaexpr variablesformatrXrrr@r.r?rr-)rrrrrrrr g_ys_expr g_ys_varsk g_ys_vars_1exp_invsg_ys rrrsD {dajj(~ c Axx' AFF?"1hvaQ/?&FO Oxx' AEE>Q''):):AJJGG1::&"1hva1~t&DfM MxxVV     ! 4&t6::q)!8 a. / / a+ , , a   qvv;?NO Oqvvay'q))+a.(A4H&R R!Sahhh166QVV+; dH % % I ,,Iell3y>23A$*Kx ~1Q3r6CPYNCZ@[+.s9~+>A?)ABC**sS^O_B` bcdH"155(; ; i ( (*.<*.3( Kxq!QqSVc#h5F2G/23s8}3=)>?@zz K*.<=H#155(; ;!+-?@AA'88 9>> from sympy import Mul, oo >>> from sympy.abc import x >>> from sympy.solvers.solveset import domain_check >>> g = 1/(1 + (1/(x + 1))**2) >>> domain_check(g, x, -1) False >>> domain_check(x**2, x, 0) True >>> domain_check(1/x, x, oo) False * The function relies on the assumption that the original form of the equation has not been changed by automatic simplification. >>> domain_check(x/x, x, 0) # x/x is automatically simplified to 1 True * To deal with automatic evaluations use evaluate=False: >>> domain_check(Mul(x, 1/x, evaluate=False), x, 0) False F)r is_infinite _domain_check)rrps r domain_checkrNxs*< 1:wqzq}} A &&rc^^UR(aUR(agURTT5R(ag[ U[ 5(a_UR HNup4URTT5nU[RLaM,U[RLa[UTT5s $ g g[UU4SjUR 55$)NTFc3>># UHn[UTT5v M g7fr)rL).0rrMrs r _domain_check..s$$"q!FA..") is_Atom is_finitesubsrKrr=rrrrrLall)rrrMr4condcondsubss `` rrLrLsyyQ[[   & & Ay ! !&&JDyy+H177"QVV#$T6155!"$FF$$ $rc ^U4SjnURVs0sHo3[S0U"U5D6_M nnURU5R$s snf)a Return True if the given expression is finite. For symbols that do not assign a value for `complex` and/or `real`, the domain will be used to assign a value; symbols that do not assign a value for `finite` will be made finite. All other assumptions are left unmodified. c>URnURSURSS55 TR[R 5(aURSS5 U$URSS5 U$)NfiniteTrcomplex) assumptions0 setdefaultgetrrr)rArs r assumptions0_is_finite_with_finite_vars..assumptionssd NN XquuXt45   AGG $ $ LL &  LLD )rr)rrxreplacerV)rrrcrrepss ` r_is_finite_with_finite_varsrgsL 12 ?1u&{1~& &D ? ::d  % %% @sAc^^UR(dUR(a [UU4SjUR55$UR(a8UR R T5(d[TURT5$gUR T5(dg[UT5(a-[URST5nUR5S:*$g![a gf=f)aTests whether the equation is an equation of the given function class. The given equation belongs to the given function class if it is comprised of functions of the function class which are multiplied by or added to expressions independent of the symbol. In addition, the arguments of all such functions must be linear in the symbol as well. Examples ======== >>> from sympy.solvers.solveset import _is_function_class_equation >>> from sympy import tan, sin, tanh, sinh, exp >>> from sympy.abc import x >>> from sympy.functions.elementary.trigonometric import TrigonometricFunction >>> from sympy.functions.elementary.hyperbolic import HyperbolicFunction >>> _is_function_class_equation(TrigonometricFunction, exp(x) + tan(x), x) False >>> _is_function_class_equation(TrigonometricFunction, tan(x) + sin(x), x) True >>> _is_function_class_equation(TrigonometricFunction, tan(x**2), x) False >>> _is_function_class_equation(TrigonometricFunction, tan(x + 2), x) True >>> _is_function_class_equation(HyperbolicFunction, tanh(x) + sinh(x), x) True c3>># UHn[TUT5v M g7fr)_is_function_class_equation)rQr@ func_classrs rrR._is_function_class_equation..s$&$s/z3GG$rTFTrr) rrrXrrr5rrjrrrfrgri)rkrrrs` ` rrjrjs6 xx188&ff&& & xxuuyy  .z1666J J 55==!Z   QVVAY'A88:? "  s7+C$$ C10C1cB[[USS9SS9n[U5up4URU5(d [ X1U5$[X1U5n[XAU5nXV- $![ a [ U[US5U5s$[a [Rs$f=f)zsolve rational functionsT) recursive)deepr) rhrr)r_solve_as_polyr?rYrrlrr _solveset)rrrrr valid_solns invalid_solnss r_solve_as_rationalrts!t,48A A;DA 55== !!V4 4 62 !!V4 **# : 1a&9 9 ::  s A!BBBc\rSrSrSrSrg)_SolveTrig1Erroriz0Raised when _solve_trig1 heuristics do not applyrNrrrrrvrvs:rrvc Sup4[U5HTn[U[[45(dM UR U5(dM8U(dUSpCMDXS:XaUS- nMPSup4 O US:Xa[ USX5upgXa:XaSnUR U1- (a\URSRUSS9upU RUSS9upU R5up[U S5[U S5-n[XU5$[U[US5U5$U(ac[S5nURX>5n[XU5n[U[ 5(a&[#UVs/sHn[%UU- X5PM sn6$S n['XU5nU$s snf![(a3 [+XU5nU$![,a [/[1S 55ef=ff=f) z@Function to call other helpers to solve trigonometric equations rr)FrrTas_AddFrNzj Solution to this kind of trigonometric equations is yet to be implemented)r#rrQrCrrrrrrrrYrrrWsolvesetrTrX _solve_trig _solve_trig1rv _solve_trig2rr?rz)rrr trig_exprcountr4rsolrYrrmrrrf_covsol_covrs rr{r{sI"1% d2.0 1 159XXf5E5E#'5" #+ & zAv. ;D%%0 ~~a(77t7L''u'=++-#qzBsAJ.c2 21a&9 9  #Jy$5V, gy ) )DKLGq+ik6:GLN N C .1f- JM . .q&1C J  .%j2,'-. . . .s$%F F G# F22GGc 4^[S5n[[UT5(a<[U5nUR [ R 5(a[O[nO[[U-5n[n[U5nUnUR[[5nUVs/sHoRSPM n n[U4SjU 55(d [UTU5$/n /n U Hn [!U T5n U R'5S:a [%S5eU R'5S:XaMEU R)5SnU R+[-U5S5 U R+[-U5S5 M [/U 5[1U 5- nUR3TX-5nUR5[5n[7U5n[-U5unn[S5nUR95UR95nnUR3UU5UR3UU5nnUR;U5(dUR;U5(a [%S5e[=UU5[=UU5- n[?U[@5(a [%S 5e[?U[B5(Ga[S U55(a [%S 5eUR3UTU- 5n[EUVs/sHnU"UUT5SPM sn6nUR;[F5(anUR[F5n[-U5unnURH"US S 06SnURH"US S 06Sn[K[MUS5[MUS55nOSnU[ RNLa [ATUU5$[ATUUU55$U[ RRLa[ RR$[%S5es snf!["a [%S5ef=fs snf)a^Primary solver for trigonometric and hyperbolic equations Returns either the solution set as a ConditionSet (auto-evaluated to a union of ImageSets if no variables besides 'symbol' are involved) or raises _SolveTrig1Error if f == 0 cannot be solved. Notes ===== Algorithm: 1. Do a change of variable x -> mu*x in arguments to trigonometric and hyperbolic functions, in order to reduce them to small integers. (This step is crucial to keep the degrees of the polynomials of step 4 low.) 2. Rewrite trigonometric/hyperbolic functions as exponentials. 3. Proceed to a 2nd change of variable, replacing exp(I*x) or exp(x) by y. 4. Solve the resulting rational equation. 5. Use invert_complex or invert_real to return to the original variable. 6. If the coefficients of 'symbol' were symbolic in nature, add the necessary consistency conditions in a ConditionSet. rrc3D># UHoRT5v M g7fr)r)rQrrs rrR_solve_trig1..|s5nuuV}}n z!trig argument is not a polynomialrz°ree of variable must not exceed onerzchange of variable not possiblez$polynomial has ConditionSet solutionc3B# UHn[U[5v M g7fr)rrjrQrs rrRrs4ez!V$$ez#polynomial results in RootOf objectryFTz(polynomial solutions must form FiniteSet)*rrjrCr5rrrrinvert_complexrr*rrQranyrzrfrirvrg all_coeffsrr)r%r$rWrewriterhexpandrsolveset_complexrrYrTrXr rrRrrrWr)rrrrcovinverter f_originaltrig_functionsr)trig_arguments denominators numeratorsarpoly_arcmurrrsolnsrresultsymsmunummudencondnumconddenrYs ` rr|r|Xs, c A"#5q&AA!f"("2"2177";";;!A#h! AJWW24FGN)78AffQiN8 5n5 5 5 FF33LJ H2v&G >> a "#KL L >> q      #(1+a.)HQKN+ \ 3z? *B vrtA #A A A;DAq c A 88:qxxzqA 66#q>166#q>qAuuQxx15588@AA Q "%5a%; ;E%&&EFF%## 4e4 4 4"#HI Ihhq&)$eDe#q&1!4eDE 66&>>::f%D#B>  Z2&G >> a YZ Z >> q      # C   hqkmm ,    . c A !Z. .z:/F FB v!tA #AAA A A;DA c A 88:qxxzq 66#a&! affSVQ/quuQxx15588FBz1$5v>> Q177 #hq!QWW&= =E%## %' %1%S^Q?B %'(3vy>2v6q9 !9vay 64(FFF++ !** zzFBz1$5qww??q9  ZXY Y Z C:q(96B B C*'s+M  MAM+ %NM(+!NNc SnURU5(a[XSSSSS9n[UR55n[ X5U::a[ UR 56nGOj[X5nUR"5nUR"5[U5::a [ U6nGO&[U[US5U5nGO [U5nUc[U[US5U5nURVs/sHowRU5(dMUPM nn[U5S:XGa[XhS5nURn UR"5n [UR"5URSS9n[ [USSSS9R 56n [U 5U :a[U[US5U5nX:wa[!S 5n UR#[$R&5(a[(O[*n U "XU5upX:Xa[-U Vs/sHnUR/U U5PM sn6n[1U[ 5(aR[1U [25(a=U R4R6(a"[ UVs/sHn[9U5PM sn6nO/[U[US5U5nO[U[US5U5nUb[1U[ 5(aA[;S U55(a*[!S 5n[=[?U[AU55U5n[1U[ 5(a%U[$RB:waUREU5nU$[U[US5U5$s snfs snfs snf) z Solve the equation using polynomial techniques if it already is a polynomial equation or, with a change of variables, can be made so. NTEX)cubicsquarticsquinticsrrr) composite)rrrrc3# UHFnUR[[5[5:H=(a [ U[ 5(+v MH g7fr)rr rsetrrjrs rrR!_solve_as_poly..5s<$"q776<0CE9W*QPVBW>WW"sAAr)# is_polynomialresumrIrgrTkeysrf all_rootsrrYrgensrgenas_exprrrrrrrrXrWrrrr2rrXrUrrr intersection)rrrrr num_rootsrorrrdeg poly_solnsrrlhsrhs_srrs rrprps Fvat#D2 ' !  ) -F?DNN$E{{}E *"E*%fbAh?Aw <!&"Q(F;F9969af 96 t9>1g&D((C++-C DAD"E$td37%99=AJ:$%fbAh?}#J*0*:*:177*C*C;%cf5 ="z$Jz!UZZ1%5z$JKF!&)44C::"%(("6"6!*F,KFqZ]F,K!L)&"Q(FCF!&"Q(F;F  fi ( ( $"$$$#J!&N1,=">G fi ( (Vq{{-B((0F FBq!Hf55W7$%K-Ls6M<M<NNc ^^^^UnU(aUOT/4upVU(d4U"UT5[[TT5Vs/sH os"UT5PM sn6- nOUupU"U [- U 5(d0[SSS9n U R X05n UR X05nU n U"U T5n U"XY5n [U Vs/sHn[ [ X5U 5PM sn6nUU4SjmUU4SjmT"U5nU$s snfs snf)z1Helper function to solve equations with radicals yrealTrc>/n/nUH9n[TTU5(aURU5 M(URU5 M; [U6[T[ TS5[U65-$r)rtrrTrYr) solutionsf_setc_setrrrs rcheck_finiteset'_solve_radical..check_finitesetUsbA61%% Q Q  % <1a)UBS#TTTrc>U[RLaU$[U[5(aU$[U[5(aT"U5$[U[ 5(a UR up[ T"U5U5$[U[5(a)[UR Vs/sH nT"U5PM sn6$U$s snfr)rrrrYrTr[rrX)rrbBrr check_sets rr!_solve_radical..check_set_s  "   < 0 0   9 - -"9- -  : . .>>DAilA. .  5 ) )@A9Q<@A A  As(C)rXrurrrerUr)runradfrsolveset_solverreqrrrryeqrg_y_sf_y_solsr< solution_setrrs` ` @@r_solve_radicalrBs  Ccq"gGB  V, q&8IJ8I1OAv.8IJ KLq1ua(('-E,,z*CaZ(BAV,"2)$)+$)S"&.(;$)+,U$V$L WK+s C/ 4C4cUR[R5(d[[ S55e[ S5[ S5[ S5pTnUR U[U5-U-5=(d 0nX4U4Vs/sH"ovRU[R5PM$ snupn UR(dU R(d|[XU5nSSK J n U "U S:USUS S 9n U RU5n [X-U -U5R!U 5n[X*-U -U5R!U 5n[#X5$[%U['US5U5$s snf) zDHelper function to solve equation involving absolute value function zR Absolute values cannot be inverted in the complex domain.rMrrrsolve_univariate_inequalityrFT) relationalr continuous)rrrrrzr matchr?rarrr inequalitiesr complement solveset_realrrXrYr)rrrrMrr pattern_matchrf_pf_qf_rr q_pos_cond q_neg_cond sols_q_pos sols_q_negs r _solve_absrvsG   AGG $ $% ! !3icDI!AGGAc!fHqL)/RM<=!9E9a&&q!&&19EMCc KK3;;"37=06>> from sympy import exp, sin, Symbol, pprint, S >>> from sympy.solvers.solveset import solve_decomposition as sd >>> x = Symbol('x') >>> f1 = exp(2*x) - 3*exp(x) + 2 >>> sd(f1, x, S.Reals) {0, log(2)} >>> f2 = sin(x)**2 + 2*sin(x) + 1 >>> pprint(sd(f2, x, S.Reals), use_unicode=False) 3*pi {2*n*pi + ---- | n in Integers} 2 >>> f3 = sin(x + 2) >>> pprint(sd(f3, x, S.Reals), use_unicode=False) {2*n*pi - 2 | n in Integers} U {2*n*pi - 2 + pi | n in Integers} r) decompogenr)sympy.solvers.decompogenrrTrrWrrrrzrrYrZrXrr3r4tupler base_setsr)rrrrg_sy_srfrangerrr iter_isetiset new_solutions dummy_varbase_set new_exprsnew_exprs rsolve_decompositionrs.4 Q C A,C 626' c9 % %$RXv> !)\::'F #x(( F C''HH  "zz!! (DJJOOQ)? P !$**//">">?B "nn mY77 -I |<<!-"4"4Q"7CC$1$6$6q$9 )Hhvi'BHMMF!*" QZZ 1a&9 9OR JrFc t ^SSKJn [U[5(aT$UnUR(aQUR USS9up`U[ R[ R[ R1;a [U5nOUR(anUR U5upxUR USS9upU [ R[ R[ R[ R1;aXy- U-nT4Sjn U4Sjn [ Rn UR5R(aT$UR!U5(d[ R$UR(aN[#U4SjUR$55(a*['UR$V s/sH o"X5PM sn 6n GO[)[*X5(d[)[,X5(a[/XT5n GOQ[U[05(aHUR$Sn[3[5[7U5S:UT5[5[9U5UT55n GOUR:(aMUR=T5n U H4upUR>(aURA5nU "XU5nU U- n M6 GO[U[B5(a*U "[EURFURH*SS9UT5n GOWUR>(aS S K%J&n U"XTSS 9n U $[SX5(a[UXT5n GOU "USU5unnUU:XaL[U[V5(a3[WUVs/sHn[YU"U5R[56PM! sn6nUn GO[U[V5(GaxUVs/sHnUU- PM snGH\nUU:XGaF[]X5nU(aU [_UUUU 5- n M0UR![`5(aU [cXT5- n M[[eUUT5n[U[P5(dU U- n M[gUUT5n[U[P5(aURi5nUR(aUU:wa|UR U5unnUR(dW/n[XRj"U5H3nUR!U5(dMURmU "UU55 M5 ['U6nU U- n GMQX"UU5- n GM_ O*U[ RLa[QU[CUS5T5n [U [P5(ar[U[n5(a]URq5unn U R!U5(a4[5UUT5n![U![P5(d[5U UT5n"U!U"- n U(a[U [P5(aU $[U[n5(a'UR US S9S n#U#R USS9S n#OUn#[U [V5(aB[WU V$s/sH.n$[U$[r5(d[uU#UU$5(dM,U$PM0 sn$6n U $s sn f![Na [QXT5n U $f=fs snfs snfs sn$f) zHelper for solveset to return a result from an expression that has already been sympify'ed and is known to contain the given symbol.r)signsimpFrxc[XU5$r)rq)rrrs rr_solveset..s 1)@rc>[XUT5$r)r)rrrrs rrrsgaff&Erc3<># UHn[UT5v M g7fr)rg)rQrrs rrR_solveset..s"6a@@rrr)rrT);sympy.simplify.simplifyrrrSrrrr0r/r1rhrrrrrrrXrrXrjrQrCr{r@rWrqrArB is_Piecewiseas_expr_set_pairs is_Relationalas_setrr rrrrr?rY _is_modular_solve_modularrTr as_content_primitivervrr?rrt _transolverk make_argsrrrrjrN)%rrr_checkrorig_fcoeffrrrsolverrrexpr_set_pairsr4in_setrrrrrrequationuresult_rationalt_resultfactored_dep t_resultsfacrr_result singularitiesfxrs% ` rrqrqs 1![!! Fxx##F5#9 Q&&(:(:AJJG G A 'u5 Q&& 002 2aA"( @FEH ZZFxxz UU6]]zz cVVAFF;Fq*F;< %&;Q G G '(:A F FQ/ As   FF1Ii1 66B'1vv>@ ,,V4,NT##40E eOF - Ar  AEEAEE6E:FFK = 50 f8F Q  62aF+ U &=%++!"$$"%(QK446%8"$$%F y ) )278%3S3Y%8q=a(A.11717#99"c***Q"??*B""6%"8;BB fi ( (F!6Fq#Av..%b&!4"#F!67F Mi<.# 5!&V4F  5 $$ 9F!6s0-Z Z'&Z+/Z0+Z5=Z5Z('Z(c|UR[5(dg[UR[55n[ U5S:H=(ao USR SRU5=(aG USR SR =(a$ [S[[U5555$)a Helper function to check below mentioned types of modular equations. ``A - Mod(B, C) = 0`` A -> This can or cannot be a function of symbol. B -> This is surely a function of symbol. C -> It is an integer. Parameters ========== f : Expr The equation to be checked. symbol : Symbol The concerned variable for which the equation is to be checked. Examples ======== >>> from sympy import symbols, exp, Mod >>> from sympy.solvers.solveset import _is_modular as check >>> x, y = symbols('x y') >>> check(Mod(x, 3) - 1, x) True >>> check(Mod(x, 3) - 1, y) False >>> check(Mod(x, 3)**2 - 5, x) False >>> check(Mod(x, 3)**2 - y, x) False >>> check(exp(Mod(x, 3)) - 1, x) False >>> check(Mod(3, y) - 1, y) False Frrc3B# UHn[U[5v M g7fr)rrrQterms rrR_is_modular..s!0.4%%.r) rrrrrr is_integerr _term_factors)rrmodtermss rrr{sL 55::AGGCL!H MQ  0 QK  Q  # #F + 0 QK  Q  * * 0 0]1-.0 0rc URupEURSLaU[R4$URSLd)[ S[ [U5555(aX4$[U5[U5:aU[R4$XC:Xa+U[[X%U-U-5[R54$UR(aSURU5upgU[RLa-U[Xe5- n[![Xu5[X5X#5$UR"(aSURU5upgU[R$La-U['Xe5-n[![Xu5[X5X#5$UR((GaURupU R+U5(Ga@U R+U5(Gd)UR,(d/UR,(aUR.R,(aX4$UR0[3UR0UR05-n [5XR0UR.R05n [9U5n [;U 5HLn[=UR.X[3UR0UR.R05- 5S:XdMJUn O U [[X-U-U -5[R>54$U R+U5(aU R+U5(dn[AXUSS9nU/:XaU[R4$[RnUH/nU[[X%U-U-5[R5- nM1 U U4$X4$![6a X4s$f=f![6[B4a X4s$f=f)a Helper function to invert modular equation. ``Mod(a, m) - rhs = 0`` Generally it is inverted as (a, ImageSet(Lambda(n, m*n + rhs), S.Integers)). More simplified form will be returned if possible. If it is not invertible then (modterm, rhs) is returned. The following cases arise while inverting equation ``Mod(a, m) - rhs = 0``: 1. If a is symbol then m*n + rhs is the required solution. 2. If a is an instance of ``Add`` then we try to find two symbol independent parts of a and the symbol independent part gets transferred to the other side and again the ``_invert_modular`` is called on the symbol dependent part. 3. If a is an instance of ``Mul`` then same as we done in ``Add`` we separate out the symbol dependent and symbol independent parts and transfer the symbol independent part to the rhs with the help of invert and again the ``_invert_modular`` is called on the symbol dependent part. 4. If a is an instance of ``Pow`` then two cases arise as following: - If a is of type (symbol_indep)**(symbol_dep) then the remainder is evaluated with the help of discrete_log function and then the least period is being found out with the help of totient function. period*n + remainder is the required solution in this case. For reference: (https://en.wikipedia.org/wiki/Euler's_theorem) - If a is of type (symbol_dep)**(symbol_indep) then we try to find all primitive solutions list with the help of nthroot_mod function. m*n + rem is the general solution where rem belongs to solutions list from nthroot_mod function. Parameters ========== modterm, rhs : Expr The modular equation to be inverted, ``modterm - rhs = 0`` symbol : Symbol The variable in the equation to be inverted. n : Dummy Dummy variable for output g_n. Returns ======= A tuple (f_x, g_n) is being returned where f_x is modular independent function of symbol and g_n being set of values f_x can have. Examples ======== >>> from sympy import symbols, exp, Mod, Dummy, S >>> from sympy.solvers.solveset import _invert_modular as invert_modular >>> x, y = symbols('x y') >>> n = Dummy('n') >>> invert_modular(Mod(exp(x), 7), S(5), n, x) (Mod(exp(x), 7), 5) >>> invert_modular(Mod(x, 7), S(5), n, x) (x, ImageSet(Lambda(_n, 7*_n + 5), Integers)) >>> invert_modular(Mod(3*x + 8, 7), S(5), n, x) (x, ImageSet(Lambda(_n, 7*_n + 6), Integers)) >>> invert_modular(Mod(x**4, 7), S(5), n, x) (x, EmptySet) >>> invert_modular(Mod(2**(x**2 + x + 1), 7), S(2), n, x) (x**2 + x + 1, ImageSet(Lambda(_n, 3*_n + 1), Naturals0)) Fc3># UHnURSLv M g7f)FN)is_realrs rrR"_invert_modular..s #0.$(<<5#8.srT)r)"rrrrr$rrr absrZrrrrrr_invert_modularrrrmrr is_IntegerrrMrrcrr>rbpow Naturals0rdr?)modtermrrrrrrr x_indep_termrrmdiv remainderrrMremainder_listg_nrems rr'r's T <va|+L"3q9c,.BAN NxxxVV  88F  DHHV$4$4<>> from sympy.solvers.solveset import _solve_modular as solve_modulo >>> from sympy import S, Symbol, sin, Intersection, Interval, Mod >>> x = Symbol('x') >>> solve_modulo(Mod(5*x - 8, 7) - 3, x, S.Integers) ImageSet(Lambda(_n, 7*_n + 5), Integers) >>> solve_modulo(Mod(5*x - 8, 7) - 3, x, S.Reals) # domain should be subset of integers. ConditionSet(x, Eq(Mod(5*x + 6, 7) - 3, 0), Reals) >>> solve_modulo(-7 + Mod(x, 5), x, S.Integers) EmptySet >>> solve_modulo(Mod(12**x, 21) - 18, x, S.Integers) ImageSet(Lambda(_n, 6*_n + 2), Naturals0) >>> solve_modulo(Mod(sin(x), 7) - 3, x, S.Integers) # not solvable ConditionSet(x, Eq(Mod(sin(x), 7) - 3, 0), Integers) >>> solve_modulo(3 - Mod(x, 5), x, Intersection(S.Integers, Interval(0, 100))) Intersection(ImageSet(Lambda(_n, 5*_n + 3), Integers), Range(0, 101, 1)) rrTr)rYrrrrrrrWras_coefficients_dictrrrrrr'rrrZr3r4r5rrqrTrr)rrrunsolved_resultr+rrrr0 lamda_expr lamda_varsrsol_settmp_solrs rrrCs`#62a8V>> from sympy import symbols >>> from sympy.solvers.solveset import _term_factors >>> x = symbols('x') >>> list(_term_factors(-2 - x**2 + x*(x + 1))) [-2, -1, x**2, x, x + 1] N)r rr )radd_args rr r s/.==#==)))$)s3A? Ac .[U[X- S5U5n[U5nX:wa![XQ- 5nX`U- :wa [ XbU5$[ U[ 5(a[UR5S:XdU$US:waU$[[UR55upxURU5Sn URU5Sn U R5upU R5upUR[R5(a;[!U S:U S:[[#U 5S5[[#U5S55nO [![%U S5[%U S55nSXx*45unn[ UU- X#5n[X/U5$)a Helper function for solving (supported) exponential equations. Exponential equations are the sum of (currently) at most two terms with one or both of them having a power with a symbol-dependent exponent. For example .. math:: 5^{2x + 3} - 5^{3x - 1} .. math:: 4^{5 - 9x} - e^{2 - x} Parameters ========== lhs, rhs : Expr The exponential equation to be solved, `lhs = rhs` symbol : Symbol The variable in which the equation is solved domain : Set A set over which the equation is solved. Returns ======= A set of solutions satisfying the given equation. A ``ConditionSet`` if the equation is unsolvable or if the assumptions are not properly defined, in that case a different style of ``ConditionSet`` is returned having the solution(s) of the equation with the desired assumptions. Examples ======== >>> from sympy.solvers.solveset import _solve_exponential as solve_expo >>> from sympy import symbols, S >>> x = symbols('x', real=True) >>> a, b = symbols('a b') >>> solve_expo(2**x + 3**x - 5**x, 0, x, S.Reals) # not solvable ConditionSet(x, Eq(2**x + 3**x - 5**x, 0), Reals) >>> solve_expo(a**x - b**x, 0, x, S.Reals) # solvable but incorrect assumptions ConditionSet(x, (a > 0) & (b > 0), {0}) >>> solve_expo(3**(2*x) - 2**(x + 3), 0, x, S.Reals) {-3*log(2)/(-2*log(3) + log(2))} >>> solve_expo(2**x - 4**x, 0, x, S.Reals) {0} * Proof of correctness of the method The logarithm function is the inverse of the exponential function. The defining relation between exponentiation and logarithm is: .. math:: {\log_b x} = y \enspace if \enspace b^y = x Therefore if we are given an equation with exponent terms, we can convert every term to its corresponding logarithmic form. This is achieved by taking logarithms and expanding the equation using logarithmic identities so that it can easily be handled by ``solveset``. For example: .. math:: 3^{2x} = 2^{x + 3} Taking log both sides will reduce the equation to .. math:: (2x)\log(3) = (x + 3)\log(2) This form can be easily handed by ``solveset``. rrrc3H# UHn[[U5SS9v M g7f)TforceN)rr.rQrs rrR%_solve_exponential..$s >> from sympy import symbols, cos, exp >>> from sympy.solvers.solveset import _is_exponential as check >>> x, y = symbols('x y') >>> check(y, y) False >>> check(x**y - 1, y) True >>> check(x**y*2**y - 1, y) True >>> check(exp(x + 3) + 3**x, x) True >>> check(cos(2**x), x) False * Philosophy behind the helper The function extracts each term of the equation and checks if it is of exponential form w.r.t ``symbol``. FT)r rrrrr5)rrrvexpr_args r_is_exponentialrO*saH B!!$ .. .  x % % 33 3 h $ $B% Irc6[USS9nXA- n[XRU5$)aa Helper to solve logarithmic equations which are reducible to a single instance of `\log`. Logarithmic equations are (currently) the equations that contains `\log` terms which can be reduced to a single `\log` term or a constant using various logarithmic identities. For example: .. math:: \log(x) + \log(x - 4) can be reduced to: .. math:: \log(x(x - 4)) Parameters ========== lhs, rhs : Expr The logarithmic equation to be solved, `lhs = rhs` symbol : Symbol The variable in which the equation is solved domain : Set A set over which the equation is solved. Returns ======= A set of solutions satisfying the given equation. A ``ConditionSet`` if the equation is unsolvable. Examples ======== >>> from sympy import symbols, log, S >>> from sympy.solvers.solveset import _solve_logarithm as solve_log >>> x = symbols('x') >>> f = log(x - 3) + log(x + 3) >>> solve_log(f, 0, x, S.Reals) {-sqrt(10), sqrt(10)} * Proof of correctness A logarithm is another way to write exponent and is defined by .. math:: {\log_b x} = y \enspace if \enspace b^y = x When one side of the equation contains a single logarithm, the equation can be solved by rewriting the equation as an equivalent exponential equation as defined above. But if one side contains more than one logarithm, we need to use the properties of logarithm to condense it into a single logarithm. Take for example .. math:: \log(2x) - 15 = 0 contains single logarithm, therefore we can directly rewrite it to exponential form as .. math:: x = \frac{e^{15}}{2} But if the equation has more than one logarithm as .. math:: \log(x - 3) + \log(x + 3) = 0 we use logarithmic identities to convert it into a reduced form Using, .. math:: \log(a) + \log(b) = \log(ab) the equation becomes, .. math:: \log((x - 3)(x + 3)) This equation contains one logarithm and can be solved by rewriting to exponents. Tr=)r-rq)rrrrnew_lhsnew_fs r_solve_logarithmrS[s%fD)G ME UF ++rcSn[R"U5HbnSn[R"U5H8nXR;aM[ U[ 5(aU(a gSnM7 g U(dM`SnMd U$)a Return ``True`` if the equation is in the form `a\log(f(x)) + b\log(g(x)) + ... + c` else ``False``. Parameters ========== f : Expr The equation to be checked symbol : Symbol The variable in which the equation is checked Returns ======= ``True`` if the equation is logarithmic otherwise ``False``. Examples ======== >>> from sympy import symbols, tan, log >>> from sympy.solvers.solveset import _is_logarithmic as check >>> x, y = symbols('x y') >>> check(log(x + 2) - log(x + 3), x) True >>> check(tan(log(2*x)), x) False >>> check(x*log(x), x) False >>> check(x + log(x), x) False >>> check(y + log(x), x) True * Philosophy behind the helper The function extracts each term and checks whether it is logarithmic w.r.t ``symbol``. FT)r rr rrr.)rrrMrsaw_logterm_args r_is_logarithmicrWsrR B a  d+H222(C(( , 7B! Irc ^^[[UR555n[UVs/sHo3R"T5(dMUPM sn5n[UVs/sH'nUR"[ [ 5(dM%UPM) sn5nUR(aUUS:aO[[ [ 4m[UU4SjU55(aXT:agg[U4SjU55(aggs snfs snf)a If this returns ``False`` then the Lambert solver (``_solve_lambert``) will not be called. Explanation =========== Quick check for cases that the Lambert solver might be able to handle. 1. Equations containing more than two operands and `symbol`s involving any of `Pow`, `exp`, `HyperbolicFunction`,`TrigonometricFunction`, `log` terms. 2. In `Pow`, `exp` the exponent should have `symbol` whereas for `HyperbolicFunction`,`TrigonometricFunction`, `log` should contain `symbol`. 3. For `HyperbolicFunction`,`TrigonometricFunction` the number of trigonometric functions in equation should be less than number of symbols. (since `A*cos(x) + B*sin(x) - c` is not the Lambert type). Some forms of lambert equations are: 1. X**X = C 2. X*(B*log(X) + D)**A = C 3. A*log(B*X + A) + d*X = C 4. (B*X + A)*exp(d*X + g) = C 5. g*exp(B*X + h) - B*X = C 6. A*D**(E*X + g) - B*X = C 7. A*cos(X) + B*sin(X) - D*X = C 8. A*cosh(X) + B*sinh(X) - D*X = C Where X is any variable, A, B, C, D, E are any constants, g, h are linear functions or log terms. Parameters ========== f : Expr The equation to be checked symbol : Symbol The variable in which the equation is checked Returns ======= If this returns ``False`` then the Lambert solver (``_solve_lambert``) will not be called. Examples ======== >>> from sympy.solvers.solveset import _is_lambert >>> from sympy import symbols, cosh, sinh, log >>> x = symbols('x') >>> _is_lambert(3*log(x) - x*log(3), x) True >>> _is_lambert(log(log(x - 3)) + log(x-3), x) True >>> _is_lambert(cosh(x) - sinh(x), x) False >>> _is_lambert((x**2 - 2*x + 1).subs(x, (log(x) + 3*x)**2 - 1), x) True See Also ======== _solve_lambert rc3l># UH)oR"T5(dM[UT5v M+ g7fr)rr)rQr@ lambert_funcsrs rrR_is_lambert..?s,8#wwv.z#}--#s44Tc3># UHDoR"5SRT5(dM,[U[[45v MF g7f)rN)rArrrr5)rQr@rs rrRr[Ds@K#(9!(<'A'A&'I-C#s,,#s +AAF) rr rrrrCrQrr.r)rr term_factorsr@ no_of_symbols no_of_trigrZs ` @r _is_lambertr`sJ ahhj12L H  HIM\?\c 77%'< =\?@J xxMQ&02GH 8#8 8 8-. K#KKK #I?sC> C>"$D DcSn[U[US5U5n[USX5upV[U[5(aF[ UR 5S:XdeUR SnUR(a U"XWX5nU$UnU$)aU Function to solve transcendental equations. It is a helper to ``solveset`` and should be used internally. ``_transolve`` currently supports the following class of equations: - Exponential equations - Logarithmic equations Parameters ========== f : Any transcendental equation that needs to be solved. This needs to be an expression, which is assumed to be equal to ``0``. symbol : The variable for which the equation is solved. This needs to be of class ``Symbol``. domain : A set over which the equation is solved. This needs to be of class ``Set``. Returns ======= Set A set of values for ``symbol`` for which ``f`` is equal to zero. An ``EmptySet`` is returned if ``f`` does not have solutions in respective domain. A ``ConditionSet`` is returned as unsolved object if algorithms to evaluate complete solution are not yet implemented. How to use ``_transolve`` ========================= ``_transolve`` should not be used as an independent function, because it assumes that the equation (``f``) and the ``symbol`` comes from ``solveset`` and might have undergone a few modification(s). To use ``_transolve`` as an independent function the equation (``f``) and the ``symbol`` should be passed as they would have been by ``solveset``. Examples ======== >>> from sympy.solvers.solveset import _transolve as transolve >>> from sympy.solvers.solvers import _tsolve as tsolve >>> from sympy import symbols, S, pprint >>> x = symbols('x', real=True) # assumption added >>> transolve(5**(x - 3) - 3**(2*x + 1), x, S.Reals) {-(log(3) + 3*log(5))/(-log(5) + 2*log(3))} How ``_transolve`` works ======================== ``_transolve`` uses two types of helper functions to solve equations of a particular class: Identifying helpers: To determine whether a given equation belongs to a certain class of equation or not. Returns either ``True`` or ``False``. Solving helpers: Once an equation is identified, a corresponding helper either solves the equation or returns a form of the equation that ``solveset`` might better be able to handle. * Philosophy behind the module The purpose of ``_transolve`` is to take equations which are not already polynomial in their generator(s) and to either recast them as such through a valid transformation or to solve them outright. A pair of helper functions for each class of supported transcendental functions are employed for this purpose. One identifies the transcendental form of an equation and the other either solves it or recasts it into a tractable form that can be solved by ``solveset``. For example, an equation in the form `ab^{f(x)} - cd^{g(x)} = 0` can be transformed to `\log(a) + f(x)\log(b) - \log(c) - g(x)\log(d) = 0` (under certain assumptions) and this can be solved with ``solveset`` if `f(x)` and `g(x)` are in polynomial form. How ``_transolve`` is better than ``_tsolve`` ============================================= 1) Better output ``_transolve`` provides expressions in a more simplified form. Consider a simple exponential equation >>> f = 3**(2*x) - 2**(x + 3) >>> pprint(transolve(f, x, S.Reals), use_unicode=False) -3*log(2) {------------------} -2*log(3) + log(2) >>> pprint(tsolve(f, x), use_unicode=False) / 3 \ | --------| | log(2/9)| [-log\2 /] 2) Extensible The API of ``_transolve`` is designed such that it is easily extensible, i.e. the code that solves a given class of equations is encapsulated in a helper and not mixed in with the code of ``_transolve`` itself. 3) Modular ``_transolve`` is designed to be modular i.e, for every class of equation a separate helper for identification and solving is implemented. This makes it easy to change or modify any of the method implemented directly in the helpers without interfering with the actual structure of the API. 4) Faster Computation Solving equation via ``_transolve`` is much faster as compared to ``_tsolve``. In ``solve``, attempts are made computing every possibility to get the solutions. This series of attempts makes solving a bit slow. In ``_transolve``, computation begins only after a particular type of equation is identified. How to add new class of equations ================================= Adding a new class of equation solver is a three-step procedure: - Identify the type of the equations Determine the type of the class of equations to which they belong: it could be of ``Add``, ``Pow``, etc. types. Separate internal functions are used for each type. Write identification and solving helpers and use them from within the routine for the given type of equation (after adding it, if necessary). Something like: .. code-block:: python def add_type(lhs, rhs, x): .... if _is_exponential(lhs, x): new_eq = _solve_exponential(lhs, rhs, x) .... rhs, lhs = eq.as_independent(x) if lhs.is_Add: result = add_type(lhs, rhs, x) - Define the identification helper. - Define the solving helper. Apart from this, a few other things needs to be taken care while adding an equation solver: - Naming conventions: Name of the identification helper should be as ``_is_class`` where class will be the name or abbreviation of the class of equation. The solving helper will be named as ``_solve_class``. For example: for exponential equations it becomes ``_is_exponential`` and ``_solve_expo``. - The identifying helpers should take two input parameters, the equation to be checked and the variable for which a solution is being sought, while solving helpers would require an additional domain parameter. - Be sure to consider corner cases. - Add tests for each helper. - Add a docstring to your helper that describes the method implemented. The documentation of the helpers should identify: - the purpose of the helper, - the method used to identify and solve the equation, - a proof of correctness - the return values of the helpers c[U[X- S5U5n[X5(a[XX#5nU$[ X5(a [ XX#5nU$)z Helper for ``_transolve`` to handle equations of ``Add`` type, i.e. equations taking the form as ``a*f(x) + b*g(x) + .... = c``. For example: 4**x + 8**x = 0 r)rYrrOrKrWrS)rrrrrs radd_type_transolve..add_typesYfbA&6? 3 ' ''&AF  S ) )%c?F rrr)rYrrrrTrrr)rrrrcrrrrs rrrJsf$&"Q(F 3F 1f5JC%##EJJA%%%jjm ::c7F M Mrc[U5n[U5nU[RLaU$U[RLa[R$[ U[ [[45(d[SU-5e[ U[ [45(dUb[U<S35e[ U[5(d[SU-5eURnUR[5(a [U5nUcbU(d[[US5nU[RLaU$U[RLa[R$[![#SU-55eUc<[%U5S:XaUR'5nOdU(a[[#S55eOH[ U[(5(d3[+U/U/5upn[-USUSU5R/U5$SnUR1[R25(aUR4S S 0:wa [7S S S 9nO@UR1[R85(aUR4S S 0:wa [7SS S9nUbI[-UR/X05Xr5nUR/Xq05n UR=U 5(aU nU$[?U[@5up URC[5nU HHupU REU RFSRC[55n UR/X05nMJ [U5n[IXUS S9$![:a Un Nf=f)ar Solves a given inequality or equation with set as output Parameters ========== f : Expr or a relational. The target equation or inequality symbol : Symbol The variable for which the equation is solved domain : Set The domain over which the equation is solved Returns ======= Set A set of values for `symbol` for which `f` is True or is equal to zero. An :class:`~.EmptySet` is returned if `f` is False or nonzero. A :class:`~.ConditionSet` is returned as unsolved object if algorithms to evaluate complete solution are not yet implemented. ``solveset`` claims to be complete in the solution set that it returns. Raises ====== NotImplementedError The algorithms to solve inequalities in complex domain are not yet implemented. ValueError The input is not valid. RuntimeError It is a bug, please report to the github issue tracker. Notes ===== Python interprets 0 and 1 as False and True, respectively, but in this function they refer to solutions of an expression. So 0 and 1 return the domain and EmptySet, respectively, while True and False return the opposite (as they are assumed to be solutions of relational expressions). See Also ======== solveset_real: solver for real domain solveset_complex: solver for complex domain Examples ======== >>> from sympy import exp, sin, Symbol, pprint, S, Eq >>> from sympy.solvers.solveset import solveset, solveset_real * The default domain is complex. Not specifying a domain will lead to the solving of the equation in the complex domain (and this is not affected by the assumptions on the symbol): >>> x = Symbol('x') >>> pprint(solveset(exp(x) - 1, x), use_unicode=False) {2*n*I*pi | n in Integers} >>> x = Symbol('x', real=True) >>> pprint(solveset(exp(x) - 1, x), use_unicode=False) {2*n*I*pi | n in Integers} * If you want to use ``solveset`` to solve the equation in the real domain, provide a real domain. (Using ``solveset_real`` does this automatically.) >>> R = S.Reals >>> x = Symbol('x') >>> solveset(exp(x) - 1, x, R) {0} >>> solveset_real(exp(x) - 1, x) {0} The solution is unaffected by assumptions on the symbol: >>> p = Symbol('p', positive=True) >>> pprint(solveset(p**2 - 4)) {-2, 2} When a :class:`~.ConditionSet` is returned, symbols with assumptions that would alter the set are replaced with more generic symbols: >>> i = Symbol('i', imaginary=True) >>> solveset(Eq(i**2 + i*sin(i), 1), i, domain=S.Reals) ConditionSet(_R, Eq(_R**2 + _R*sin(_R) - 1, 0), Reals) * Inequalities can be solved over the real domain only. Use of a complex domain leads to a NotImplementedError. >>> solveset(exp(x) > 1, x, R) Interval.open(0, oo) z"%s is not a valid SymPy expressionNz is not a valid SymPy symbolz%s is not a valid domainrz@ relationship between value and 0 is unknown: %srzh The independent variable must be specified for a multivariate equation.rTrJrr^C)r^)r)%rrrrrrrrrrr]rrr=r<rr?rzrpopr rxrzrerr_assumptions_origrrrdummy_eqrr?rrrrq) rrrrrrswapnewsymrM_rvrdr)s rrzrz! sJ  A V_FAFF{ AGG|zz a$ F3 4 4=ABB ftZ0 1 1v7IVEFF fc " "3f=>>>>LuuY 1  ~l q!H ;M !''\:: %j2CEF2G'HI I~ |  !!%%'F Z)*+, , ' '&sVH5 d!adF+44T::F    # #~ 53T*F   !++ & &  # # 4'8 83-F  ajj&!12F C ++v./C ;;s  B aoGA )A FF166!9$$Y/ 0 JJv  qA Qt 44) C s M MMc6[X[R5$r)rzrrrrs rrr s Aqww ''rc6[X[R5$r)rzrrros rrr s Aq{{ ++rc ^0n[TU5H0upEU[RLdM[URSS9X4'M2 UVs/sHofR U5PM nnTVs/sHoDR U5PM snm[ T5m[U5S:Xa[U6$[T5S:XaTTSnUSnUVs/sHn[XdU5PM nn[U6n [[U4U45U 5R5$[UU4SjS9n[U5GH up/n Sn THnUWR ;aM[XdUTR#U55n [%U [&5(aTR#U5nTSUTUS-S-nUSUX.S-S-nUSU X S-S-nU HsnUVs/sHofR UU5PM nn[)UUU5n[U4USUU4-XS-5nU R+[UU5R55 Mu MSn GM U (dGM[-U 6s $ gs snfs snfs snfs snf) zeBasic implementation of a multivariate solveset. For internal use (not ready for public consumption)TrrrcF>[UR[T5-5$r)rrr)rrs rr!_solveset_multi.. sS3t9)D%ErkeyNF)ziprrr namerWrrr^rzrWrZrdoitsortedrrindexrrT_solveset_multirrX)eqsrdomainsreprdomrrsolsetssolsetrsols all_handledrrsymspdomainspeqspreqsp_sub sol_othersfuns ` rr{r{ sN Cg& !''>chhT2CH'#& &#B773<#C &%) *TcHHSMT *D ;D 3x1}7## 4yA~1g7:;s8BV,s;w'vv.7<<>> E FC3 C"//)2GDJJsO$<=C#y))JJsORa4!:-"2A;162AwqST*A:>?$BQ$H?!05(!KJ %5!9t+;eBi+GHCKKj 9 > > @A  $ !" ;$< + # ' *<( @sI (II9I c [XU5nSnU[RLa/nU$[U[5(a [ S5e[U[ 5(a [U5nU$[X5nUb[RnSn[U[5(aU4nOB[U[5(a-[SUR55(a URnUH"nXhR[SUSS55- nM$ [U[ 5(a [U5nU$URU5n[U[5(am[SUR55(aKURV V s/sH0n U RHn [U [ 5(dMU PM M2 nn n U$g[U[ 5(aXH- nU$s sn n f) a;Solves an equation using solveset and returns the solution in accordance with the `solve` output API. Returns ======= We classify the output based on the type of solution returned by `solveset`. Solution | Output ---------------------------------------- FiniteSet | list ImageSet, | list (if `f` is periodic) Union | Union | list (with FiniteSet) EmptySet | empty list Others | None Raises ====== NotImplementedError A ConditionSet is the input. Examples ======== >>> from sympy.solvers.solveset import solvify >>> from sympy.abc import x >>> from sympy import S, tan, sin, exp >>> solvify(x**2 - 9, x, S.Reals) [-3, 3] >>> solvify(sin(x) - 1, x, S.Reals) [pi/2] >>> solvify(tan(x), x, S.Reals) [0] >>> solvify(exp(x) - 1, x, S.Complexes) >>> solvify(exp(x) - 1, x, S.Reals) [0] Nz*solveset is unable to solve this equation.rc3B# UHn[U[5v M g7frrrZr?s rrRsolvify..T sJ8I1z!X..8IrrFTc3B# UHn[U[5v M g7fr)rrTr?s rrRrb sGAz!Y//r)rzrrrrYr?rTrrrZrXrXrrrVr) rrrrrrriter_solutionssolutionsolnrs rsolvifyr s^Av.L Fqzz!N MK L, / /!"NOO L) , ,l#B M=Q'   IN,11".L%00J 8I8IJJJ%1%6%6N*//FE40PQQ +)Y//i M$--f5H(E**GGGG.6mmImd $ ZY-G" )"mFI M  Hi00" MIs )G0 G)dictcP[U5n[U5S:Xa6[US5(a#[US[5(d [ S5e[ U5n[U5[U5:wa [ S5e[U/U5upEUSnUSnU(aU(aXT[R'U$[R/[U5S--nXWS'[U5HupX;aM XIXx'M U$![an[[U55eSnAff=f)a6Return a list whose elements are the coefficients of the corresponding symbols in the sum of terms in ``eq``. The additive constant is returned as the last element of the list. Raises ====== NonlinearError The equation contains a nonlinear term ValueError duplicate or unordered symbols are passed Parameters ========== dict - (default False) when True, return coefficients as a dictionary with coefficients keyed to syms that were present; key 1 gives the constant term Examples ======== >>> from sympy.solvers.solveset import linear_coeffs >>> from sympy.abc import x, y, z >>> linear_coeffs(3*x + 2*y - 1, x, y) [3, 2, -1] It is not necessary to expand the expression: >>> linear_coeffs(x + y*(z*(x*3 + 2) + 3), x) [3*y*z + 1, y*(2*z + 3)] When nonlinear is detected, an error will be raised: * even if they would cancel after expansion (so the situation does not pass silently past the caller's attention) >>> eq = 1/x*(x - 1) + 1/x >>> linear_coeffs(eq.expand(), x) [0, 1] >>> linear_coeffs(eq, x) Traceback (most recent call last): ... NonlinearError: nonlinear in given generators * when there are cross terms >>> linear_coeffs(x*(y + 1), x, y) Traceback (most recent call last): ... NonlinearError: symbol-dependent cross-terms encountered * when there are terms that contain an expression dependent on the symbols that is not linear >>> linear_coeffs(x**2, x) Traceback (most recent call last): ... NonlinearError: nonlinear in given generators rrz!expecting unpacked symbols, *symsduplicate symbols givenNr)r"rr~rr rrr&rrrstrrrrr) rrrsymsetrmrerrrMrr9s r linear_coeffsrs sD "B 4yA~(47++JtAw4N4N<== YF 6{c$i233'!2$/ aD aD aeeH &&3t9q= !B rF$ :   I 'SX&&'sD D% D  D%cJU(d[[S55e[US[5(a [ S5e[ USS5(aUSn[ U5(a [S5e[U5n[U[5(a [U5nOC[U[[45(aU/nO$[U5(d[[S55e[X5up#[#U5[#U54=upVn[%['U[)U555n[+U6n [-U5HupU Hn Xn XXU 4'M M [/USUVs/sHo*PM sn5nX4$![an[[!U55eSnAff=fs snf) a@ Converts a given System of Equations into Matrix form. Here ``equations`` must be a linear system of equations in ``symbols``. Element ``M[i, j]`` corresponds to the coefficient of the jth symbol in the ith equation. The Matrix form corresponds to the augmented matrix form. For example: .. math:: 4x + 2y + 3z & = 1 \\ 3x + y + z & = -6 \\ 2x + 4y + 9z & = 2 This system will return :math:`A` and :math:`b` as: .. math:: A = \left[\begin{array}{ccc} 4 & 2 & 3 \\ 3 & 1 & 1 \\ 2 & 4 & 9 \end{array}\right] \\ .. math:: b = \left[\begin{array}{c} 1 \\ -6 \\ 2 \end{array}\right] The only simplification performed is to convert ``Eq(a, b)`` :math:`\Rightarrow a - b`. Raises ====== NonlinearError The equations contain a nonlinear term. ValueError The symbols are not given or are not unique. Examples ======== >>> from sympy import linear_eq_to_matrix, symbols >>> c, x, y, z = symbols('c, x, y, z') The coefficients (numerical or symbolic) of the symbols will be returned as matrices: >>> eqns = [c*x + z - 1 - c, y + z, x - y] >>> A, b = linear_eq_to_matrix(eqns, [x, y, z]) >>> A Matrix([ [c, 0, 1], [0, 1, 1], [1, -1, 0]]) >>> b Matrix([ [c + 1], [ 0], [ 0]]) This routine does not simplify expressions and will raise an error if nonlinearity is encountered: >>> eqns = [ ... (x**2 - 3*x)/(x - 3) - 3, ... y**2 - 3*y - y*(y - 4) + x - 4] >>> linear_eq_to_matrix(eqns, [x, y]) Traceback (most recent call last): ... NonlinearError: symbol-dependent term can be ignored using `strict=False` Simplifying these equations will discard the removable singularity in the first and reveal the linear structure of the second: >>> [e.simplify() for e in eqns] [x - 3, x + y - 4] Any such simplification needed to eliminate nonlinear terms must be done *before* calling this routine. zd Symbols must be given, for which coefficients are to be found. rz;Unordered 'set' type is not supported as input for symbols.__iter__zSymbols must be uniquezb Equation(s) must be given as a sequence, Expr, Eq or Matrix. Nr)rrzrrrrr|rrarrrr}r&rrrrrrrvranger_rr`) equationssymbolsrrrrrshapeixrbrowrmr9colrrs rlinear_eq_to_matrixr sj %  '!*c"" IK Kwqz:&&!*122 "I)Z((O Ibz * *K  # #%  '"96r7CL((DA5 c'58$ %B u AB-A%C$A3hK  q!!_!Qb!_%A 4K 'SX&&'%s# E:$ F : FFFc,^U(d[R$U(a[USS5(aUSn[U[5nSnSn[US5(a[ U5S:Xa[US[ 5(aUupT[US[ 5(dU(dU(d[[S55e[ [U55[ U5:wa [U5eUnUVs/sHn[U5PM nn[Xa5mTc[R$[[!U4SjU565mT$O^[U[ 5(aIU(a-[U[5(d[US[ 5(dUSS2SS24USS2SS24pEUc [S 5eU(a[#WR$5V s/sHn ['U5PM nn [U5n [)XR*UR*--5(a3[[S USR,R/S 5-55e[ U 5[ U5:wa [U5eU(dP[#WR$5V s/sH n [15PM nn [3S XT4S S9R,n [5U 5n OSn /nWR75n[9X5H[unn[9X5VVs/sHunnU(dMUU-PM nnnUR;U*5 UR;[=U65 M] [?Xa5unn[AUUSS9mTc[R$[[!U4SjU565mU bATR*nUVs0sHnUU;dM U['U 5_M nnTRCU5mT$s snf![an[[U55eSnAff=fs sn fs sn fs snnfs snf)az Solve system of $N$ linear equations with $M$ variables; both underdetermined and overdetermined systems are supported. The possible number of solutions is zero, one or infinite. Zero solutions throws a ValueError, whereas infinite solutions are represented parametrically in terms of the given symbols. For unique solution a :class:`~.FiniteSet` of ordered tuples is returned. All standard input formats are supported: For the given set of equations, the respective input types are given below: .. math:: 3x + 2y - z = 1 .. math:: 2x - 2y + 4z = -2 .. math:: 2x - y + 2z = 0 * Augmented matrix form, ``system`` given below: $$ \text{system} = \left[{array}{cccc} 3 & 2 & -1 & 1\\ 2 & -2 & 4 & -2\\ 2 & -1 & 2 & 0 \end{array}\right] $$ :: system = Matrix([[3, 2, -1, 1], [2, -2, 4, -2], [2, -1, 2, 0]]) * List of equations form :: system = [3x + 2y - z - 1, 2x - 2y + 4z + 2, 2x - y + 2z] * Input $A$ and $b$ in matrix form (from $Ax = b$) are given as: $$ A = \left[\begin{array}{ccc} 3 & 2 & -1 \\ 2 & -2 & 4 \\ 2 & -1 & 2 \end{array}\right] \ \ b = \left[\begin{array}{c} 1 \\ -2 \\ 0 \end{array}\right] $$ :: A = Matrix([[3, 2, -1], [2, -2, 4], [2, -1, 2]]) b = Matrix([[1], [-2], [0]]) system = (A, b) Symbols can always be passed but are actually only needed when 1) a system of equations is being passed and 2) the system is passed as an underdetermined matrix and one wants to control the name of the free variables in the result. An error is raised if no symbols are used for case 1, but if no symbols are provided for case 2, internally generated symbols will be provided. When providing symbols for case 2, there should be at least as many symbols are there are columns in matrix A. The algorithm used here is Gauss-Jordan elimination, which results, after elimination, in a row echelon form matrix. Returns ======= A FiniteSet containing an ordered tuple of values for the unknowns for which the `system` has a solution. (Wrapping the tuple in FiniteSet is used to maintain a consistent output format throughout solveset.) Returns EmptySet, if the linear system is inconsistent. Raises ====== ValueError The input is not valid. The symbols are not given. Examples ======== >>> from sympy import Matrix, linsolve, symbols >>> x, y, z = symbols("x, y, z") >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]]) >>> b = Matrix([3, 6, 9]) >>> A Matrix([ [1, 2, 3], [4, 5, 6], [7, 8, 10]]) >>> b Matrix([ [3], [6], [9]]) >>> linsolve((A, b), [x, y, z]) {(-1, 2, 0)} * Parametric Solution: In case the system is underdetermined, the function will return a parametric solution in terms of the given symbols. Those that are free will be returned unchanged. e.g. in the system below, `z` is returned as the solution for variable z; it can take on any value. >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> b = Matrix([3, 6, 9]) >>> linsolve((A, b), x, y, z) {(z - 1, 2 - 2*z, z)} If no symbols are given, internally generated symbols will be used. The ``tau0`` in the third position indicates (as before) that the third variable -- whatever it is named -- can take on any value: >>> linsolve((A, b)) {(tau0 - 1, 2 - 2*tau0, tau0)} * List of equations as input >>> Eqns = [3*x + 2*y - z - 1, 2*x - 2*y + 4*z + 2, - x + y/2 - z] >>> linsolve(Eqns, x, y, z) {(1, -2, -2)} * Augmented matrix as input >>> aug = Matrix([[2, 1, 3, 1], [2, 6, 8, 3], [6, 8, 18, 5]]) >>> aug Matrix([ [2, 1, 3, 1], [2, 6, 8, 3], [6, 8, 18, 5]]) >>> linsolve(aug, x, y, z) {(3/10, 2/5, 0)} * Solve for symbolic coefficients >>> a, b, c, d, e, f = symbols('a, b, c, d, e, f') >>> eqns = [a*x + b*y - c, d*x + e*y - f] >>> linsolve(eqns, x, y) {((-b*f + c*e)/(a*e - b*d), (a*f - c*d)/(a*e - b*d))} * A degenerate system returns solution as set of given symbols. >>> system = Matrix(([0, 0, 0], [0, 0, 0], [0, 0, 0])) >>> linsolve(system, x, y) {(x, y)} * For an empty system linsolve returns empty set >>> linsolve([], x) EmptySet * An error is raised if any nonlinearity is detected, even if it could be removed with expansion >>> linsolve([x*(1/x - 1)], x) Traceback (most recent call last): ... NonlinearError: nonlinear term: 1/x >>> linsolve([x*(y + 1)], x, y) Traceback (most recent call last): ... NonlinearError: nonlinear cross-term: x*(y + 1) >>> linsolve([x**2 - 1], x) Traceback (most recent call last): ... NonlinearError: nonlinear term: x**2 rrrNrz When passing a system of equations, the explicit symbols for which a solution is being sought must be given as a sequence, too. c3F># UHnTRX5v M g7frrarQrrs rrRlinsolve.., s#I#CGGC$5$5!rzInvalid argumentsa At least one of the symbols provided already appears in the system to be solved. One way to avoid this is to use Dummy symbols in the generator, e.g. numbered_symbols('%s', cls=Dummy) 1234567890tauc6[U5RS5$)Nr)rrstrip)rs rrlinsolve..G sc!fmmL9r)compareF)_rawc3F># UHnTRX5v M g7frrrs rrRrY sA#CGGC--r)"rrrrrrrarrzrrrsrrrrrTr rcolsrrrrwrrr!r{tolistrvrr rprqrW)systemrsym_gendup_msgrrbr|rexcrrrrwrrowsrowibielemrtermsringsolsymr~rs @rlinsolverP sZ zz771:z22!*-0G'G Avz"" v;!  6!9j A ADA&)Z00g -" 3w< CL0 ))C),-272;C- /- {zz!E#I#IJKCJ91< FJ ' ' Jw >> wqz: . .a"f~vaf~1y,--*/-8-Q4=-8W v!..89 : :Z) !*//((6 )789 9 [CL (W% % $)!&&M2Mq57M2%eaV9;;?4 % C 88:DLb-0-?H-? c4-?H bS 3;! "#/IC T .C {zz EAAB CC !!)0B#C6M~sDI~Bhhsm J}.& /$SX.. /&93ICsB5O OPP>P  P # P1P O>%O99O>c~SU5n[[U6[U6[R[ U5-5nU$)Nc3:# UHn[US5v M g7f)rN)r)rQrs rrR'_return_conditionset..j s %#2c1::s)rYr rRrrr)r|r condition_sets r_return_conditionsetrh s8 % %C  wcAKKW$=?M rc ^^^^^ ^!^"^#^$^%^&^'^(U(d[R$[U5H7upg[U[5(dMUR UR - X'M9 U(dSn[[U55e[U5(d$Sn[[U[U5U4-55e[USSS5(d*Sn[[U[US5US4-55eTcUmUn 0m%0m'Sn Sn SUU4Sjjm$[[UU$4S j55m&S n U%U'4S jm"U4S jm!S m#SSjmSUU!U#4Sjjm Sn U U"U$U%U&U'4SjnU"U [5unnnU"U [ 5unnnU UU-- n U UU-- n X:XaU S:wa [#T&T5$/n[U5Hn[U5HgnUR%5UR%5:waM'['S[)UR+5UR+5555(dMf Mw UR-U5 M UU-n/n/nUHnU(dM [/U5[/T5:aHUR%5m([(4SjT55nUHnUUU'M UR-U5 UU;dMtUR-U5 M U(aUnT'(dT%(a U "UT'T%5n[RnUH/nTVs/sHnUUPM nnU[3[5U55- nM1 U$s snf)a Solves the `system` using substitution method. It is used in :func:`~.nonlinsolve`. This will be called from :func:`~.nonlinsolve` when any equation(s) is non polynomial equation. Parameters ========== system : list of equations The target system of equations symbols : list of symbols to be solved. The variable(s) for which the system is solved known_symbols : list of solved symbols Values are known for these variable(s) result : An empty list or list of dict If No symbol values is known then empty list otherwise symbol as keys and corresponding value in dict. exclude : Set of expression. Mostly denominator expression(s) of the equations of the system. Final solution should not satisfy these expressions. all_symbols : known_symbols + symbols(unsolved). Returns ======= A FiniteSet of ordered tuple of values of `all_symbols` for which the `system` has solution. Order of values in the tuple is same as symbols present in the parameter `all_symbols`. If parameter `all_symbols` is None then same as symbols present in the parameter `symbols`. Please note that general FiniteSet is unordered, the solution returned here is not simply a FiniteSet of solutions, rather it is a FiniteSet of ordered tuple, i.e. the first & only argument to FiniteSet is a tuple of solutions, which is ordered, & hence the returned solution is ordered. Also note that solution could also have been returned as an ordered tuple, FiniteSet is just a wrapper `{}` around the tuple. It has no other significance except for the fact it is just used to maintain a consistent output format throughout the solveset. Raises ====== ValueError The input is not valid. The symbols are not given. AttributeError The input symbols are not :class:`~.Symbol` type. Examples ======== >>> from sympy import symbols, substitution >>> x, y = symbols('x, y', real=True) >>> substitution([x + y], [x], [{y: 1}], [y], set([]), [x, y]) {(-1, 1)} * When you want a soln not satisfying $x + 1 = 0$ >>> substitution([x + y], [x], [{y: 1}], [y], set([x + 1]), [y, x]) EmptySet >>> substitution([x + y], [x], [{y: 1}], [y], set([x - 1]), [y, x]) {(1, -1)} >>> substitution([x + y - 1, y - x**2 + 5], [x, y]) {(-3, 4), (2, -1)} * Returns both real and complex solution >>> x, y, z = symbols('x, y, z') >>> from sympy import exp, sin >>> substitution([exp(x) - sin(y), y**2 - 4], [x, y]) {(ImageSet(Lambda(_n, I*(2*_n*pi + pi) + log(sin(2))), Integers), -2), (ImageSet(Lambda(_n, 2*_n*I*pi + log(sin(2))), Integers), 2)} >>> eqs = [z**2 + exp(2*x) - sin(y), -3 + exp(-y)] >>> substitution(eqs, [y, z]) {(-log(3), -sqrt(-exp(2*x) - sin(log(3)))), (-log(3), sqrt(-exp(2*x) - sin(log(3)))), (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers), ImageSet(Lambda(_n, -sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers)), (ImageSet(Lambda(_n, 2*_n*I*pi - log(3)), Integers), ImageSet(Lambda(_n, sqrt(-exp(2*x) + sin(2*_n*I*pi - log(3)))), Integers))} GSymbols must be given, for which solution of the system is to be found.zBsymbols should be given as a sequence, e.g. a list.Not type %s: %srrFzEIterable of symbols must be given as second argument, not type %s: %src>URnU[T5- [T5-nU(a[U5nUR[S9 U$)z:Returns the unsolved symbol present in the equation `eq`. rt)rrrsortr)rrfreeunsolved all_symbols known_symbolss r_unsolved_syms$substitution.._unsolved_syms sG3}--[1AA H~H MM.M /rc&>[T"U55$r)r)rrs rrsubstitution.. s#nQ&7"8rcj/nUGH)nUnUR5HupgSupUR5HupX:XdM U nM UR5HupX:XdM U n M U(d U (dM][U5n U(aU[R:wa [ X5n U (a [ X5n U [R LaSn OEU R(a,[U 5S:Xa[U 5R5XV'MXU'M UcGMURU5 GM, U$)N)NNr) itemsrTrrrWr[rr>rrrgr) rintersection_dictcomplement_dict final_resultrres_copykey_res value_res intersect_setcomplement_setkey_sym value_sym new_values radd_intersection_complement1substitution..add_intersection_complement s CH&)iik"0:- *;*A*A*C&G)(1 +D+:*?*?*A&G))2+B!NN )) 4I$!++)E$0$J %$.y$I  AJJ.#'"//C Na4G,/ N,>,>,@),5))'2,###H-34rc>[U[5(a URn[U[5(a!URSTU'URSn[U[ 5(aNURn[ RnUH,n[U[5(aX- nMU[U5- nM. [U[5(aRURS[ R[ R4;aURSTU'URSn[U[5(a'UnURRn[U5nXRU'[U[5(d [U5nX4$)zSeparate the Complements, Intersections, ImageSet lambda expr and its base_set. This function returns the unmasked sol from different classes of sets and also returns the appended ImageSet elements in a soln_imageset dict: `{unmasked element: ImageSet}`. rr)rrYrr[rrXrrrTrWrrrZr3r4) rr soln_imagesetsol_argssol_arg2 soln_imagestexpr2 complements intersectionss r_extract_main_soln(substitution.._extract_main_soln s8 c< ( (,,C c: & &"xx{K ((1+C c5 ! !xxH**C%h 22OC9X..C % c< ( (xx{177AKK"88&)XXa[ c"((1+C c8 $ $LIINNEE"C#/% #y))C.C!!rc>^UmU(aDUR5nUSnUR5HupEURUS5X$'M Um[U4SjT55nU$![a SnU$f=f)Nrc3<># UHn[UT5v M g7frrt)rQrmrnew_s rrR7substitution.._check_exclude..c s"5,3qE""Gr)copyrrWrr) rnew imgset_yes rnew_copydummy_nrrsatisfy_excluderexcludes @r_check_exclude$substitution.._check_excludeR s  I mG&/oo&7"%.^^GQ%? "'8E # ""5,3"55O #"O #sA(( A87A8c[UR55[UR55-nUH nXnXPU'M X;aURU5 ggr)rrr)roriginal_imageset newresult restore_symrimgs r_restore_imgset%substitution.._restore_imgseti s]$))+& !&&( )* "G#,CM#    T " !rc[S5nU(aURUS5nUS;aUO [XUUSS9nUSLaSn0nOURU5 XU4$)Nrr)TFT)minimalF)rrWrtr)rrr delete_solnrrsatisfys r _append_eq substitution.._append_eqr s] #J ABm+"!D1Q e KC MM# K''rc6>T"X5nSn U(dSn U(aUSn USn U(a|U(au[UR[55n [S[ U 55V s/sHoPM nn [ X5n[ XRU55n[UU 5X'Ub T"XvX U 5up`n OPUb T"XvX 5up`n O@X$R5;aXBX'T"XU5 OURU5 O U(aSn 0nT"XU5 Xi4$s sn f)aSIf `rnew` (A dict ) contains valid soln append it to `newresult` list. `imgset_yes` is (base, dummy_var) if there was imageset in previously calculated result(otherwise empty tuple). `original_imageset` is dict of imageset expr and imageset from this result. `soln_imageset` dict of imageset expr and imageset of new soln. FNrrT) rrrrrrvrrWrZrr)rrrrrrrrrrlocal_nr dummy_listr local_n_list dummy_ziplamrrrs r_append_new_soln&substitution.._append_new_soln~ s5): G$Q-!!}3 "&cii&6!7J*/s:*0$1*0A*0!$1!$J =I ((9*=>C (d 3DI>3=t'4C0I[/9406, **,,). C  & KD;%%/$1s) Dc/n/nUHcn[SUR555(aM*URU5S:XaURU5 MRURU5 Me U(dU(aX#-$U$)Nc3B# UHn[U[5v M g7frr)rQvals rrR:substitution.._new_order_result.. sILSz#x00Lrr)rrIrWr)rrfirst_prioritysecond_priorityrs r_new_order_result'substitution.._new_order_result spCICJJLIII773<1$"))#.#**3/  _!3 3 rc  >^0nSnSn[T"5GHupV/nSnUGHn 0n [5n U R5Hup[U [5(adU R R X'XU 'U R R R[5R5nU RunX4n[U [5(dMe URU 5R5nU(aURUS5(dSnT "USS9nU(d2U (a(T"U SSXXU5unnU(aURU 5 GM:UR "U6unnUR["5(dUR["5(a U[$:XaGM0nUGHnSnU"UU5nUS- n[&R(n[U[*5(a!UR,ST!U'UR,Sn[U[.5(aJUR,S[1[2*[25:waUR,ST#U'UUR,S- nU(aUOUnUS:a4U[4:Xa*[U[[645(dU[%UU5- n[U[65(aRUR<[&R>[&R@4;a[&R(nSnUS- nO UR<nU[&R(La T"UUU5unnUGHXnT"UUU5unn[U5R5nURBmU (a[EU4SjU 55(aMYU RG5nU R5HHup[U [H5(dM[U[H5(dM3U RUU5UU 'MJ UURK5;aPUUnUR "[MS[OUR RP55Vs/sHnSPM sn6UU'OUUU'T"UUUXX5unnU(dGMGURU 5 GM[ U(aGMU RSU5 GM GM U(dGMUnGM XU4$![8[:4a GM3f=fs snf)zSolves the system using already known solution (result contains the dict ). solver is :func:`~.solveset_complex` or :func:`~.solveset_real`. rFT)rNrc3,># UH oT;v M g7frr)rQssrs rrRBsubstitution.._solve_using_known_values..-s.1;2$Js)*rrrrrZr3r4rrrgrrTrWrrremoverr?rrrr[rrWrVrrrYr?rrrrrrrrrrrr5add)$rr rtotal_solvest_calltotal_conditionstrzrrrrr got_symbolr9vrreq2 unsolved_syms delete_resdepen1depen2r not_solvablersoln_newrrimgstrrr rrreqs_in_better_orderrs$ @r_solve_using_known_values/substitution.._solve_using_known_values sz  ##67IEIJ$&! U IIKDA!!X..!"/0!,"#'',,"4"4U";"?"?"A"#++&-_ )!Y7777(ggcl))+cggjm&<&<"'J .s > $0@tZ-#1?- :& #MM#.!$!3!3]!CJJsOOvzz#FFVDI),DI0@ #sJ-1:- :&:#MM#.K $N(<"s+g)U~y"I8J+<<<}0<!!!Z"=s8C8S S(S% $S% c3# UHDup[U[5(a[U[5(aM1URU5v MF g7fr)rintri)rQrrs rrRsubstitution..hs<D-HTQ"1c**z!S/A!1::a==-Hs 0AAc>UT;$rr)rsolved_symbolss rrr|s !>1rFr)rrrrrrrrrzr}rtypegetattrrrrrrrrXrvrIrrfilterrTr))rrrrrrrr)msg old_resulttotal_conditionsettotal_solveset_callrrr(new_result_real solve_call1 cnd_call1new_result_complex solve_call2 cnd_call2filtered_complexjresult_all_variablesresult_infiniterr unsolved_symrsymbtemprr rrrrrr'rr.s) ``` @@@@@@@@@@r substitutionrDp sQn zz&! a   FI" (C)) w  ! 3$w-)A#ABCC 71:{E 2 22C4 +;WQZ*H$HIJJ JKM  89;@5"n.# (;?1&1&f Q=Q=f/HM/#+O[)1J$2&. Y 9y01K+5605HB5N#$7EE $ %o&Avvx1668#DSQXXZ-HDDD '  # #A &&/ /FO  s8c+& & XXZNF1;@AH ( $0L!!)  " "3 ' * * ' ' ," / : - >ZZF !$/0KD$K0)E$K((" M1sL=c[USUS5n[U[5(a[UVs/sHo34PM sn6nU$[[[U555$s snfr)rzrrTr)rrrr_solns r_solveset_workrGsZ F1Iwqz *D$ ""$/$QD$/0 y/000s A cSSKJn [U5nUR[S9 U"XSS9n/nUH"nUR UR 55 M$ 0/n[XaU/U5nU$)Nr)rnrtT)polys)sympy.polys.polytoolsrnrrrrrrD) rIrrrn_symbolsbasis new_systempoly_eqrs r_handle_positive_dimensionalrOso.G}H MM&M' UD 1EJ'//+,TF VRF Mrc ^[U/UQ76n[RnUHJn[[ [ X555m[ U4SjU55(dM<U[U5- nML U$)Nc3<># UHn[UT5v M g7frr)rQrdict_sym_values rrR+_handle_zero_dimensional..s=fxN++fr)ryrrrrrvrXrT)rIrrr result_updaterrRs @r_handle_zero_dimensionalrUsb u /w /FJJMd3w#456 =f= = = Ys^ +M rc/n/n/n/n[5nSnUGH%nUR[X55 [U[5(aUR UR - n[[U5/UQ76n U (aURU5 U upU (dU n[U[5(a&UR5SnUR"USS06nO[U5R(aMUb4URU5 URUR"55 GMURU5 GM( X#XFU4$)Nr extensionT)rupdaterwrrrrrvr(rrras_poly is_numberr) rrrI polys_exprnonpolys unrad_changedrrorwithout_radicalseq_unradrs r_separate_poly_nonpolyr`s EJHM5L DL56 b"  "&&B "88    $,MH b$  ""$Q'B::w7$7D b\ # #    LL    dlln - OOB -. hm CCrc 0/n/n/n[SU55nU(a#UVs/sHn[[USS95PM nn[XSSS9nSU;aUnUn X4$UR(alUR S5nU(aUVs/sHn[ U5PM nn[U/UQ7S S06n U V s/sHn [[X55PM nn Un X4$Un[[XSSS95n U(aU Vs/sHn[ U5PM n nX4$s snfs snfs sn f![a Un[U5n X4$f=fs snf) Nc3V# UHoRR(+v M! g7fr)ris_Exact)rQrMs rrR_handle_poly..s7Ahh''''s')T)rationalgrevlexF)orderrIrlexstrict) rror+rnis_zero_dimensionalfglmrryrrvr'r) rIrno_information no_solutions no_equationsinexactrMrLpoly_solpoly_eqsrrs r _handle_polyrrsTNLL777G=BBEqiD12EB U9E BE  Ez d  [  " " 5! (-.1VAYE. $&uDwDtDFD?c &^^U(d[R$T(dSn[[U55e[ TSS5(aTSm[ T5(aT(dSn[ [U55e[[[T55m[UT5unmmT(a8[UT5n[UVs/sHn[U4SjU55PM sn6$[U5S:Xa[T5S:Xa [UT5$[!UT5upVpxn /n 0/n U(a[#UT5upU (avU S(al[%5R&"SU56n [%5R&"SU 56n X:Xa+U (a$U Vs/sHn[)X5(dMUPM n nX-nU4SjnU(d[[UU 56$[+UTXS 9n[-U[5(dU$U (a{UR.Vs/sHn[1[3TU55PM nnUVs/sH-n[5S U55(d[)X5S :wdM+UPM/ nn[[UU56$U$s snfs snfs snfs snf) aC Solve system of $N$ nonlinear equations with $M$ variables, which means both under and overdetermined systems are supported. Positive dimensional system is also supported (A system with infinitely many solutions is said to be positive-dimensional). In a positive dimensional system the solution will be dependent on at least one symbol. Returns both real solution and complex solution (if they exist). Parameters ========== system : list of equations The target system of equations symbols : list of Symbols symbols should be given as a sequence eg. list Returns ======= A :class:`~.FiniteSet` of ordered tuple of values of `symbols` for which the `system` has solution. Order of values in the tuple is same as symbols present in the parameter `symbols`. Please note that general :class:`~.FiniteSet` is unordered, the solution returned here is not simply a :class:`~.FiniteSet` of solutions, rather it is a :class:`~.FiniteSet` of ordered tuple, i.e. the first and only argument to :class:`~.FiniteSet` is a tuple of solutions, which is ordered, and, hence ,the returned solution is ordered. Also note that solution could also have been returned as an ordered tuple, FiniteSet is just a wrapper ``{}`` around the tuple. It has no other significance except for the fact it is just used to maintain a consistent output format throughout the solveset. For the given set of equations, the respective input types are given below: .. math:: xy - 1 = 0 .. math:: 4x^2 + y^2 - 5 = 0 :: system = [x*y - 1, 4*x**2 + y**2 - 5] symbols = [x, y] Raises ====== ValueError The input is not valid. The symbols are not given. AttributeError The input symbols are not `Symbol` type. Examples ======== >>> from sympy import symbols, nonlinsolve >>> x, y, z = symbols('x, y, z', real=True) >>> nonlinsolve([x*y - 1, 4*x**2 + y**2 - 5], [x, y]) {(-1, -1), (-1/2, -2), (1/2, 2), (1, 1)} 1. Positive dimensional system and complements: >>> from sympy import pprint >>> from sympy.polys.polytools import is_zero_dimensional >>> a, b, c, d = symbols('a, b, c, d', extended_real=True) >>> eq1 = a + b + c + d >>> eq2 = a*b + b*c + c*d + d*a >>> eq3 = a*b*c + b*c*d + c*d*a + d*a*b >>> eq4 = a*b*c*d - 1 >>> system = [eq1, eq2, eq3, eq4] >>> is_zero_dimensional(system) False >>> pprint(nonlinsolve(system, [a, b, c, d]), use_unicode=False) -1 1 1 -1 {(---, -d, -, {d} \ {0}), (-, -d, ---, {d} \ {0})} d d d d >>> nonlinsolve([(x+y)**2 - 4, x + y - 2], [x, y]) {(2 - y, y)} 2. If some of the equations are non-polynomial then `nonlinsolve` will call the ``substitution`` function and return real and complex solutions, if present. >>> from sympy import exp, sin >>> nonlinsolve([exp(x) - sin(y), y**2 - 4], [x, y]) {(ImageSet(Lambda(_n, I*(2*_n*pi + pi) + log(sin(2))), Integers), -2), (ImageSet(Lambda(_n, 2*_n*I*pi + log(sin(2))), Integers), 2)} 3. If system is non-linear polynomial and zero-dimensional then it returns both solution (real and complex solutions, if present) using :func:`~.solve_poly_system`: >>> from sympy import sqrt >>> nonlinsolve([x**2 - 2*y**2 -2, x*y - 2], [x, y]) {(-2, -1), (2, 1), (-sqrt(2)*I, sqrt(2)*I), (sqrt(2)*I, -sqrt(2)*I)} 4. ``nonlinsolve`` can solve some linear (zero or positive dimensional) system (because it uses the :func:`sympy.polys.polytools.groebner` function to get the groebner basis and then uses the ``substitution`` function basis as the new `system`). But it is not recommended to solve linear system using ``nonlinsolve``, because :func:`~.linsolve` is better for general linear systems. >>> nonlinsolve([x + 2*y -z - 3, x - y - 4*z + 9, y + z - 4], [x, y, z]) {(3*z - 5, 4 - z, z)} 5. System having polynomial equations and only real solution is solved using :func:`~.solve_poly_system`: >>> e1 = sqrt(x**2 + y**2) - 10 >>> e2 = sqrt(y**2 + (-x + 10)**2) - 3 >>> nonlinsolve((e1, e2), (x, y)) {(191/20, -3*sqrt(391)/20), (191/20, 3*sqrt(391)/20)} >>> nonlinsolve([x**2 + 2/y - 2, x + y - 3], [x, y]) {(1, 2), (1 - sqrt(5), 2 + sqrt(5)), (1 + sqrt(5), 2 - sqrt(5))} >>> nonlinsolve([x**2 + 2/y - 2, x + y - 3], [y, x]) {(2, 1), (2 - sqrt(5), 1 + sqrt(5)), (2 + sqrt(5), 1 - sqrt(5))} 6. It is better to use symbols instead of trigonometric functions or :class:`~.Function`. For example, replace $\sin(x)$ with a symbol, replace $f(x)$ with a symbol and so on. Get a solution from ``nonlinsolve`` and then use :func:`~.solveset` to get the value of $x$. How nonlinsolve is better than old solver ``_solve_system`` : ============================================================= 1. A positive dimensional system solver: nonlinsolve can return solution for positive dimensional system. It finds the Groebner Basis of the positive dimensional system(calling it as basis) then we can start solving equation(having least number of variable first in the basis) using solveset and substituting that solved solutions into other equation(of basis) to get solution in terms of minimum variables. Here the important thing is how we are substituting the known values and in which equations. 2. Real and complex solutions: nonlinsolve returns both real and complex solution. If all the equations in the system are polynomial then using :func:`~.solve_poly_system` both real and complex solution is returned. If all the equations in the system are not polynomial equation then goes to ``substitution`` method with this polynomial and non polynomial equation(s), to solve for unsolved variables. Here to solve for particular variable solveset_real and solveset_complex is used. For both real and complex solution ``_solve_using_known_values`` is used inside ``substitution`` (``substitution`` will be called when any non-polynomial equation is present). If a solution is valid its general solution is added to the final result. 3. :class:`~.Complement` and :class:`~.Intersection` will be added: nonlinsolve maintains dict for complements and intersections. If solveset find complements or/and intersections with any interval or set during the execution of ``substitution`` function, then complement or/and intersection for that variable is added before returning final solution. rrrc3D># UHoRT5v M g7fr)re)rQrrjs rrRnonlinsolve..s =1aD!1!11rrc38# UHoRv M g7frrrQrs rrRrus%F"ooc38# UHoRv M g7frrwrxs rrRrus&O2ryc0>^[U4SjT55$)Nc3.># UH nTUv M g7frr)rQrrs rrR0nonlinsolve....s 9AQs)r)rrs`rrnonlinsolve..s5 9 99r)rrc3B# UHn[U[5v M g7fr)rr])rQrs rrRrus8YUXPQAs9K9KUXrF)rrrrzrr} IndexErrorrmapr"rx nonlinsolverTrrrGr`rrrunionrtrDrrrrvr)rrr3rrrIr[r\rr]rqrp poly_syms unrad_symsr remainingto_tuplesubs_resr correct_solsrjs ` @rrr;sTv zz (C))wqz:&&!* w  w(C))3x)*G-fg>FGT 67+tLt!5 =1 ==tLMM 6{aCLA-fg.. vw/=Ex}HtH )%9   %F%FGI&O&OPJ&=,4T8Cx 7SC8T#I:H #h122 78Z(I..O 9AG#d3w,-FG+1F6CS8YUX8Y5Y5Y' ;uD 6LFc(L9: :OsM*U>HFs$I?J.JJ 5*J#Jr/)rsympy.core.sympifyr sympy.corerrrrrr r r r sympy.core.containersr sympy.core.functionrrrrrrrsympy.core.modrsympy.core.numbersrrrrsympy.core.intfuncrsympy.core.relationalrrrsympy.core.sortingrrsympy.core.symbolr r!r"sympy.core.traversalr#sympy.external.gmpyr$rr%rsympy.polys.matrices.linsolver&sympy.polys.polyrootsr'rr(r)r*r+sympy.simplifyr,r-sympy.functionsr.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=%sympy.functions.combinatorial.numbersr>$sympy.functions.elementary.complexesr?r@rArB%sympy.functions.elementary.hyperbolicrCrDrErFrGrHrIrJrKrLrMrNrO(sympy.functions.elementary.miscellaneousrP(sympy.functions.elementary.trigonometricrQsympy.logic.boolalgrRrS sympy.setsrTrUrVrWrXrYrZr[r\sympy.sets.setsr]r^sympy.matricesr_r`rasympy.ntheory.factor_rbsympy.ntheory.residue_ntheoryrcrd sympy.polysrerfrgrhrirjrksympy.polys.polyerrorsrlrJrmrnrosympy.polys.solversrprqrrrssympy.solvers.solversrtrurvrwrxsympy.solvers.polysysrysympy.utilitiesrzsympy.utilities.iterablesr{r|r}r~sympy.calculus.utilrrrtypesrrrrrrrrrrr%rr-rrrNrLrgrjrt Exceptionrvr{r|r}rprrrrqrr'rr rKrOrSrWr`rrzrrr{rrrrrrDrGrOrUr`rrrrrrrs '$$$'KKK66*448<'3D<7KK088888:AAFFFF?J0MMM+44*C3331883%%3&>>NN  Z $N kk['|'mb m`GT=@.6b!'H$>+,++&0/d+*;y;8vaKH>@B&'[[B6J1h64IX\~1hQhXv*6n7b.bV,r7tYxTnAKKt5n(,/ dYB#(XvDPp+-RaH1  !DHYxhr