*hhSSKJr SSKJr SSKJr SSKJrJrJ r SSK J r J r J r JrJrJrJrJrJr SSKJrJr SSKJrJrJr SSKJr SS KJr SS KJ r J!r!J"r"J#r#J$r$J%r% SS K&J'r' SS K(J)r)J*r* SS K+J,r, SSS\4Sjr-SSjr.\ "S5r/Sr0g)) defaultdict)reduce)prod) expand_log count_ops _coeff_isneg) sympifyBasicDummySAddMulPow expand_mul factor_terms)ordereddefault_sort_key)IntegerRational equal_valued) _keep_coeff) Transform) exp_polarexplogrootpolarify unpolarify) MatrixSymbol)lcmgcd) multiplicityFallc Z^^^^^7^8^9^:^;UUUU4Sjn[U5n[U[5(a@[U[5(d+UR(dU[ S5[ S54;aU$T(d6UR (d%UR(aC[UR;a/UR"URVs/sH oe"U5PM sn6nUR(aU"U[-SS9[- $UR(dU$TS;Ga[[5n/n/n [Rn URGHOn U R (aX-n MU R(a [#U 5n U R$(aU R'5upT(aX4Vs/sH o"U5PM snupU R(d[U [(5(aX-[RpX|R+U 5 MU(amUSR'5unnU R'5unnUU:Xa>UR$(a-UR$(a[-U[/UU55US'GM>UR+U 5 GMR [1[3UR5555HupU (aU R (a[7SU 55(dtU [RLaaU [R[R84;a=[;[=U 5[=U 55nU(aU R+U5 XU--n [/U 6X|'M U [RLa2X;aXz==[R- ss'O[RXz'[?U5n[UR555n[A5nUHupU U;aM U RB=(d U RDnU(dM5SU - nU RF(a%[IU S5(a[RX|'MpU U:wdMxUU;dMU RK5S[RLa URMU 5 UU==U -ss'MUROU5 URMU5n X|==U -ss'M [UR555n[R8nUHupU RP(dU R (dM)U *U;dM2X;dM9U RBcU RR(dMYU RR(dU RT(aX|*==URMU 5- ss'OURMU *5n X|==U - ss'UU;aUU==U - ss'MXU'M UR55V V s/sHupU (dMX4PM nn n U94S jm;SU94S jjm9U8U9U:4S jn0m:/n/m8UHXupT9"X5upU T:;a T:U U -T:U 'OU T:U 'U SS:wdM1U SR(dMGT8R+U 5 MZ T8RW[XS 9 T8RWTS S9 T8GH nUT:;aM Uun nSnSnU nUn /n!/n"[ZR\"U 5HJn#T9"U#5un$n%U$T:;d T:U$U%:a/=n"n! O+U"R+U%T:U$/5 U!R+U$5 ML U"(aU"SSU"SS-n&[_S[aU"55H(nU"USU"US-n'U'S:a Ob[cU&U'5n&M* [_[aU!55H'nT:U!U==U&U"US--ss'U"U!U5 M) T:U==U&U -U-- ss'U(d&[aT:5S:Xd[7ST:55(aOz[e[ZR\"U5V#s/sH n#T;"U#5PM sn#5nUS:XaO=UU-n UU -n[7U;4Sj[ZR\"U 555(aS nGMUun n(UR+U T:RMU5[gSU(5-45 GM UnT:R55Huun n(n U R(d[U [(5(aJU([RLa7U R(R (dU R'5un nU UU(- -n O [iU U(5n UR+X45 M [aU5n)[?U5n[aU5U):XdeUR"XR55V V s/sHup[-X5PM sn n -6n TS:XaURXR"U65$U"UR"U6SS9U"U SS9-$TS:XGac/n/nURHOn U R$(a*UR+[U R'555 M>UR+U 5 MQ [_[aU55HnX~up[7SU RK555(d+U RR(dT(dU RD(dMYU RkS S9un*n+U*[RLdMU+[RLdM[-U U*5U+/X~'M [[5n,UH~upT(aU"U 5n U R (aEU RB(dU RR(a#[mU 5n [oU 5(aU *n SU - n U,U R+U 5 M A[[5nU,GHMn U,U m8[aT85S:XaT8Sn-GOU RR(dT(aUR"T86n-GO/n./n//n0T8Hn#U#RT(aU0R+U#5 M'U#Rp(aU/R+U#5 MKU#RD(aU/R+U#5 MoU.R+U#5 M [aU.5S:XaU0(a[aU05S:Xa U.(dU/RsU.U0-5 /=n.n0OU0(aSn1U R (aS n1O7U RK5un2n3U2RR(aU3RR(aS n1U1(a?U0Vs/sHof*PM n0nU.Rs[R8/[aU05-5 OU.RsU05 /n0A1U.Hn X|R+U 5 M UR"U/U0-6n-U74Sjm7[uU-SS9n4[a[.R\"U455T7"U-5:a [mU45n-UU-R+U 5 GMP UR55V V V5s/sHupU Hn5[-U U55PM M n6n n n5UR"U6U-6$[wS5es snfs snfs sn n fs sn#fs sn n fs snfs sn5n n f)a Reduce expression by combining powers with similar bases and exponents. Explanation =========== If ``deep`` is ``True`` then powsimp() will also simplify arguments of functions. By default ``deep`` is set to ``False``. If ``force`` is ``True`` then bases will be combined without checking for assumptions, e.g. sqrt(x)*sqrt(y) -> sqrt(x*y) which is not true if x and y are both negative. You can make powsimp() only combine bases or only combine exponents by changing combine='base' or combine='exp'. By default, combine='all', which does both. combine='base' will only combine:: a a a 2x x x * y => (x*y) as well as things like 2 => 4 and combine='exp' will only combine :: a b (a + b) x * x => x combine='exp' will strictly only combine exponents in the way that used to be automatic. Also use deep=True if you need the old behavior. When combine='all', 'exp' is evaluated first. Consider the first example below for when there could be an ambiguity relating to this. This is done so things like the second example can be completely combined. If you want 'base' combined first, do something like powsimp(powsimp(expr, combine='base'), combine='exp'). Examples ======== >>> from sympy import powsimp, exp, log, symbols >>> from sympy.abc import x, y, z, n >>> powsimp(x**y*x**z*y**z, combine='all') x**(y + z)*y**z >>> powsimp(x**y*x**z*y**z, combine='exp') x**(y + z)*y**z >>> powsimp(x**y*x**z*y**z, combine='base', force=True) x**y*(x*y)**z >>> powsimp(x**z*x**y*n**z*n**y, combine='all', force=True) (n*x)**(y + z) >>> powsimp(x**z*x**y*n**z*n**y, combine='exp') n**(y + z)*x**(y + z) >>> powsimp(x**z*x**y*n**z*n**y, combine='base', force=True) (n*x)**y*(n*x)**z >>> x, y = symbols('x y', positive=True) >>> powsimp(log(exp(x)*exp(y))) log(exp(x)*exp(y)) >>> powsimp(log(exp(x)*exp(y)), deep=True) x + y Radicals with Mul bases will be combined if combine='exp' >>> from sympy import sqrt >>> x, y = symbols('x y') Two radicals are automatically joined through Mul: >>> a=sqrt(x*sqrt(y)) >>> a*a**3 == a**4 True But if an integer power of that radical has been autoexpanded then Mul does not join the resulting factors: >>> a**4 # auto expands to a Mul, no longer a Pow x**2*y >>> _*a # so Mul doesn't combine them x**2*y*sqrt(x*sqrt(y)) >>> powsimp(_) # but powsimp will (x*sqrt(y))**(5/2) >>> powsimp(x*y*a) # but won't when doing so would violate assumptions x*y*sqrt(x*sqrt(y)) c>URST5nURST5nURST5nURST 5n[XX4U5$)Ndeepcombineforcemeasure)getpowsimp) argkwargs_deep_combine_force_measurer'r&r(r)s S/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/simplify/powsimp.pyrecursepowsimp..recursegsR 64(::i1GU+::i1s8X>>rF)r&)rr#c38# UHoRv M g7fN) is_Number).0eis r2 powsimp..s/Iq qc >T"U5SS$)zLReturn Rational part of x's exponent as it appears in the bkey. rr6)xbkeys r2ratqpowsimp..ratqs71:a= r5cb>UGbUR(aU[R4U4$UR(a,U[ UR 54[ UR 54$URSS9up#U[RLanUR(a/U[ UR 54U[ UR 5-4$X-[ UR 54[ UR 54$X-[R4[R4$T"UR56$)zReturn (b**s, c.q), c.p where e -> c*s. If e is not given then it will be taken by using as_base_exp() on the input b. e.g. x**3/2 -> (x, 2), 3 x**y -> (x**y, 1), 1 x**(2*y/3) -> (x**y, 3), 2 exp(x/2) -> (exp(a), 2), 1 Trational) is_Integerr One is_Rationalrqp as_coeff_Mul is_integer as_base_exp)becmrCs r2rCpowsimp..bkeys}<<quu:q=(]]wqss|,gaccl::>>4>8DA~<<$%wqss|#4a n#DD !gaccl3WQSS\AA !aee}aee33Q]]_--r5c2>[TUUS5upU(d{TRU5 U(ab[R"USU-5HAnT"U5upUT;aSTU'TU==U- ss'USS:wdM0TR U5 MC ggg)aDecide what to do with base, b. If its exponent is now an integer multiple of the Rational denominator, then remove it and put the factors of its base in the common_b dictionary or update the existing bases if necessary. If it has been zeroed out, simply remove the base. r6rN)divmodpopr make_argsappend)rQnewerrTrRbasesrCcommon_bs r2updatepowsimp..updatesXa[!A$/GD Q ]]1Q4:6#AwH,*+HQK  q( Q419!LLO 7r5)keyT)rareversec30# UH oSS:Hv M g7fr6NrA)r;ks r2r=r>Os7hQ419hsc3:># UHnT"U5S:Hv M g7frdrA)r;birDs r2r=r>\s@/?tBx1}/?srbase)r'c38# UHoRv M g7fr9)is_nonnegative)r;rBs r2r=r>sE2DQ((2Dr?rGc>UR(a[U4SjUR55$UR(a,[ URVs/sH nT"U5PM sn5$gs snf)Nc34># UH nT"U5v M g7fr9rA)r;ai_termss r2r=*powsimp.._terms..s"?"6"::sr6)is_Addsumargsis_Mulr)rRmirns r2rnpowsimp.._termssSxx""?"???xx#!&&$A&BVBZ&$ABB%BsA0z.combine must be one of ('all', 'exp', 'base').r9)(.." #uDADy==.AJJDts::,q!"4"4"#%%HK9!1'')!,5 Q !+$LL. q( #((.." # ]]DA qxxxaR8^ MM-||q}}   Q7 $LL!, q( X~  ) '( (0~~'7='7tq1FQF'7= !  .4 ,*DA:DAH}&qkAo  tqyQqT[[[ Q  ' ( w -D8#KAxDD--*B#BxHC(*hsmc.A"$ RIIsHSM23IIcN +a58RU1X-D"1c"g. eAh1a07!"4~ /"'s2wA$RUOtBqE!H}>8})7h777 s}}V/DE/DDH/DEF19DL@s}}Q/?@@@DchDAq KKHLL.x1~=> ?w|")IFQAJq#..QUUN155+<+< 21IAJ OOQF #*H >8}%%%))g~~?O(P?OtqQ?O(PPR e 99Wii&9: :499g.?01 1 F IID""T%5%5%7 89t$ s8}%A;DAE!2B2B2DEEEY^bcblbl>>4>8LE5AEE!e155&8"1e}e4 &D!DAAJxxQ]]all O??A!A !HOOA  t$A!HE5zQ 899e,B~~ 2** b)   2 s8q=CA cMM#), "NC#"E}} $ //11<tF<)Qj0<Gs0 z6z 8 z z*z 3z  z!"z&c >^ SSKJn U(aU 4Sjm /nUR[[5HTn[ UR [[45(dM*T "UR6upgUSLdMBURXW45 MV U(aURU5nU"U5up[USUS9RU5$U(a*[U5up[[[USS95U5$[U5n U R[[ SS 95$) a Collect exponents on powers as assumptions allow. Explanation =========== Given ``(bb**be)**e``, this can be simplified as follows: * if ``bb`` is positive, or * ``e`` is an integer, or * ``|be| < 1`` then this simplifies to ``bb**(be*e)`` Given a product of powers raised to a power, ``(bb1**be1 * bb2**be2...)**e``, simplification can be done as follows: - if e is positive, the gcd of all bei can be joined with e; - all non-negative bb can be separated from those that are negative and their gcd can be joined with e; autosimplification already handles this separation. - integer factors from powers that have integers in the denominator of the exponent can be removed from any term and the gcd of such integers can be joined with e Setting ``force`` to ``True`` will make symbols that are not explicitly negative behave as though they are positive, resulting in more denesting. Setting ``polar`` to ``True`` will do simplifications on the Riemann surface of the logarithm, also resulting in more denestings. When there are sums of logs in exp() then a product of powers may be obtained e.g. ``exp(3*(log(a) + 2*log(b)))`` - > ``a**3*b**6``. Examples ======== >>> from sympy.abc import a, b, x, y, z >>> from sympy import Symbol, exp, log, sqrt, symbols, powdenest >>> powdenest((x**(2*a/3))**(3*x)) (x**(2*a/3))**(3*x) >>> powdenest(exp(3*x*log(2))) 2**(3*x) Assumptions may prevent expansion: >>> powdenest(sqrt(x**2)) sqrt(x**2) >>> p = symbols('p', positive=True) >>> powdenest(sqrt(p**2)) p No other expansion is done. >>> i, j = symbols('i,j', integer=True) >>> powdenest((x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j x**(x*(i + j)) But exp() will be denested by moving all non-log terms outside of the function; this may result in the collapsing of the exp to a power with a different base: >>> powdenest(exp(3*y*log(x))) x**(3*y) >>> powdenest(exp(y*(log(a) + log(b)))) (a*b)**y >>> powdenest(exp(3*(log(a) + log(b)))) a**3*b**3 If assumptions allow, symbols can also be moved to the outermost exponent: >>> i = Symbol('i', integer=True) >>> powdenest(((x**(2*i))**(3*y))**x) ((x**(2*i))**(3*y))**x >>> powdenest(((x**(2*i))**(3*y))**x, force=True) x**(6*i*x*y) >>> powdenest(((x**(2*a/3))**(3*y/i))**x) ((x**(2*a/3))**(3*y/i))**x >>> powdenest((x**(2*i)*y**(4*i))**z, force=True) (x*y**2)**(2*i*z) >>> n = Symbol('n', negative=True) >>> powdenest((x**i)**y, force=True) x**(i*y) >>> powdenest((n**i)**x, force=True) (n**i)**x r)posifyc>[U[[45(dUR[XSS94$T"URURU-5$)NF)evaluate)rvrrrrh)rQrR_denests r2rpowdenest.._denestOsCa#s,,}}c!&???1661557+ +r5F)r(polarT)exponents_onlycHUR=(d [U[5$r9)rzrvr)rTs r2powdenest..dsahh&D*Q2D&Dr5)filter)sympy.simplify.simplifyratomsrrrvrhrrrZsubs powdenestxreplacerrr+rr|) eqr(rrrepsrMokdprepnewrs @r2rrsv/  ,#s#A!&&3*-- !&&)U?KK( $ B":56??EE 2,)Jr$$GH#NN "+C << DF GGr5yc  SSKJn UR5up#UR(d[ U[ 5(a.US:wa(UR U5nUbUnUR5up#U[RLaUR(a/n/nURHRn[S[R"U555(aURU5 MAURU5 MT U"[U65n[![ U5[U65$UR5upU [R"LaEUR(d4UR$(aUR&S:wdUR((dU$//p[R"U5HFn U R*(a!U RU R55 M5U RU 5 MH [-U 5S:XaGU SSR(d0[!U SSU SSU-5[/[U 6U-5-$U (a@[U V V s/sHup[/XU--5PM sn n 6[/[U 6U-5-$UR0(aR[3[5U55nUR(a-URupX?-nURSn[!UU5$UR(a+[S[R"U555(aU$Sn[3[5U55nUR6(aZURn[9UU5nUS:wa<UR;5unn[=UU[UVs/sHnUU- PM sn6-5n[ U[45(dUR(dURSR(d"[ URS[ 5(aW[?URS5n[AUR 5S:S:Xa#[!URBUR U-5$U$/n/nURH8nUR6(aURU5 M'URU5 M: [![ U"[U655U[U6-5$s sn n fs snf)zb Denest powers. This is a helper function for powdenest that performs the actual transformation. r) logcombiner6c3B# UHn[U[5v M g7fr9)rvr)r;rms r2r=_denest_pow..~sC1B2:b#&&1Bsc38# UHoRv M g7fr9)rw)r;ss r2r=rs?.>99.>r?cX4Vs/sHo"R5PM snup4[USUS5R5Sn[USR SS9SUSR SS9S-6n[ XV5$s snf)Nrr6T)cset)rNr!rrargs_cncr)aarrarQrSgs r2nc_gcd_denest_pow..nc_gcds+-(3(Q (3 !adO * * ,Q / !A$--T-*1-! 4 0H0KK M1  4sBT)"rrrPrzrvr _eval_powerr Exp1rsrranyr rYrZrrrJrKrLrrrrrIrrrprrNrr|rrh)rrrQrRrlogsotherr<_rpolars nonpolarsrrlogbrSrhrglogbrrrcgrgrrs r2r|r|is3 >> DAxx:a%%!q&mmA ?B??$DA AFF{qxx&&BCr1BCCC B R  #t*%3t9c5k** MMOEA QUU{AHHMMaccQhMM BImmA ;; MM"..* +   R   6{aq ! 3 36!9Q<1a03 ?A;M1NNN 6B6xYrqDz*6BC sI) *+ + ||#a&! ;;iiGA FA99Q??? ! s1v E ||zz 64  6^^%FBBs$,?$QQqS$,?'@$@AE%U\\ ::a=  :ejjmS#A#A 1 .EEII"t+5::uyy{33  C E ZZ 88 JJqM LLO  s:c3i()1S%[= 99mCH-@s S" S(N)FF)1 collectionsr functoolsrmathrsympy.core.functionrrr sympy.corer r r r r rrrrsympy.core.sortingrrsympy.core.numbersrrrsympy.core.mulrsympy.core.rulesrsympy.functionsrrrrrr"sympy.matrices.expressions.matexprr sympy.polysr r!sympy.ntheory.factor_r"r+rrxr|rAr5r2rsg#CCXXX8>>&&KK; .e5)\K~sGj 3Ze:r5