Ptj`TddlmZmZmZmZmZddlmZmZm Z ddl m Z ddl m Z ddlmZmZmZddlmZmZdZdefd Zd Zd Zdd ZdZGddeZdZdZddZ dZ!dZ"dZ#dZ$dZ%dS))AddExprMulSsympify)_mexpand count_ops expand_mul)default_sort_key)Dummy)rootsignsqrt)PolyPolynomialErrorch|jo+|jjot|jtjuS)z/Return True if expr is a sqrt, otherwise False.)is_Powexp is_RationalabsrHalf)exprs W/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/simplify/sqrtdenest.pyis_sqrtr s* ; K48/ KCMMQV4KKreturnc|tjurdS|jrdS|js|jrt d|jDSt|rt|j dzSdS)aReturn the maximum depth of any square root argument of p. >>> from sympy.functions.elementary.miscellaneous import sqrt >>> from sympy.simplify.sqrtdenest import sqrt_depth Neither of these square roots contains any other square roots so the depth is 1: >>> sqrt_depth(1 + sqrt(2)*(1 + sqrt(3))) 1 The sqrt(3) is contained within a square root so the depth is 2: >>> sqrt_depth(1 + sqrt(2)*sqrt(1 + sqrt(3))) 2 rc34K|]}t|VdSN sqrt_depth.0xs r zsqrt_depth..&s(11Q:a==111111r) r ImaginaryUnitis_Atomis_Addis_Mulmaxargsrr"baseps rr"r"s$ AOqyqx218211!&111111qzz&!&!!A%% 1rc|jrdS|jrdSt|s|jr |jjrt |jS|js|j rtd|j DSdS)aReturn True if p is comprised of only Rationals or square roots of Rationals and algebraic operations. Examples ======== >>> from sympy.functions.elementary.miscellaneous import sqrt >>> from sympy.simplify.sqrtdenest import is_algebraic >>> from sympy import cos >>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*sqrt(2)))) True >>> is_algebraic(sqrt(2)*(3/(sqrt(7) + sqrt(5)*cos(2)))) False TFc34K|]}t|VdSr ) is_algebraicr#s rr&zis_algebraic..Cs(33q<??333333r) rr(rrr is_Integerr2r-r)r*allr,r.s rr2r2,s  } t u qxAE$4AF### QX33AF333333urc|dkrdgg}nn|dkr ddgddgddgg}n\|dkrgdgdgdgdgd gd gd g}n>t|dz }d |D}d |D}|dg|dz zdgzgz|z}|S)ag Returns all possible subsets of the set (0, 1, ..., n-1) except the empty set, listed in reversed lexicographical order according to binary representation, so that the case of the fourth root is treated last. Examples ======== >>> from sympy.simplify.sqrtdenest import _subsets >>> _subsets(2) [[1, 0], [0, 1], [1, 1]] rr)rrr)rrr)rrr)rrr)rrr)rrr)rrrcg|]}|dgz S)rr#s r z_subsets.._ ! ! !!a1#g ! ! !rcg|]}|dgz S)rr9r#s rr:z_subsets..`r;r)_subsets)naba0a1s rr=r=Hs AvvSE aVaVaV $ a YY 999 YY 999iii 9 QUOO ! !q ! ! ! ! !q ! ! ! 1#q1u+#$ $r ) Hrr7c~t|}t|D]}t|}||kr|cS|}|S)aDenests sqrts in an expression that contain other square roots if possible, otherwise returns the expr unchanged. This is based on the algorithms of [1]. Examples ======== >>> from sympy.simplify.sqrtdenest import sqrtdenest >>> from sympy import sqrt >>> sqrtdenest(sqrt(5 + 2 * sqrt(6))) sqrt(2) + sqrt(3) See Also ======== sympy.solvers.solvers.unrad References ========== .. [1] https://web.archive.org/web/20210806201615/https://researcher.watson.ibm.com/researcher/files/us-fagin/symb85.pdf .. [2] D. J. Jeffrey and A. D. Rich, 'Symplifying Square Roots of Square Roots by Denesting' (available at https://www.cybertester.com/data/denest.pdf) )r range _sqrtdenest0)rmax_iterizs r sqrtdenestrIesQ6 d  D 8__    199KKK Krcddlm}t|}|jr|tjtjf}n|jrRt|jt}d|D}td|Dr#||\}}}|||f}t|Sdt|D}t|t} | ddkrg}n| \} } } || }|| tj}|jrtg} g}|jD]@}t#|| kr| |+||At'j| }t'j|}g}|g}|D]}|d| kr||d*|d}||kr|dN|jrft|j}||vr2|||t'|||d||dt-|}t-|}|||dzf}n;|\}}t1|rtj||dzf}ng}t|S) aReturn [a, b, r] for p.match(a + b*sqrt(r)) where, in addition to matching, sqrt(r) also has then maximal sqrt_depth among addends of p. Examples ======== >>> from sympy.functions.elementary.miscellaneous import sqrt >>> from sympy.simplify.sqrtdenest import _sqrt_match >>> _sqrt_match(1 + sqrt(2) + sqrt(2)*sqrt(3) + 2*sqrt(1+sqrt(5))) [1 + sqrt(2) + sqrt(6), 2, 1 + sqrt(5)] r) split_surdskeycg|]}|dzS)r6r9r#s rr:z_sqrt_match..s&&&1!Q$&&&rc32K|]}|jo|jVdSr )r is_positive)r$sqs rr&z_sqrt_match..s+BBRr~0".BBBBBBrc8g|]\}}t|||fSr9r!)r$rGr%s rr:z_sqrt_match..s) @ @ @tq!jmmQ " @ @ @rrr6)sympy.simplify.radsimprKr is_NumberrZeror)sortedr,r r4list enumerater+popOner*r"appendr _from_argsremover as_coeff_Mulr)r/rKrespargssqargsrr@r?vnmaxdepth_rGbvrvr%rBb1x1x1argss r _sqrt_matchrls322222 A{<!&!&! :qv#3444&&&&& BB6BBB B B !k!nnGAq!Q'C99  A @y/?/? @ @ @1*+++ 7a<<CCKE1a ! A EE!HHHAx '%%A!!}}u,, !  ! N2&&N2&&BB , ,Q4%<<IIadOOOO1BQww ! 9,%)"']]F F{{ & a 0 0 0 " #v, 7 7 7 7 " !A$IIadOOOORARAaA,CC~~1 1:: 61ad#CCC 99rceZdZdS)SqrtdenestStopIterationN)__name__ __module__ __qualname__r9rrrnrnsDrrnct|r|\}}|tjur|jjrt |jjt}t|dkr9td|Dr t|S#t$rYnwxYwtttd|D}t!|Sd||fD\}}||z St#|trg}g}|jD]C}|\}}||||Dtd|Dr)td|Drt)||St#|t*r|j}|r|jd|DS|S) z+Returns expr after denesting its arguments.rLr6c3*K|]}|dzjVdS)r6N)r3r#s rr&z_sqrtdenest0..s)(I(Iq!Q$):(I(I(I(I(I(Irc,g|]}t|Sr9rEr#s rr:z _sqrtdenest0..s*I*I*Iq<??*I*I*Irc,g|]}t|Sr9ru)r$rGs rr:z _sqrtdenest0..s444LOO444rc3$K|] }|jV dSr )r)r$cs rr&z_sqrtdenest0..s$))q}))))))rc34K|]}t|VdSr )r)r$args rr&z_sqrtdenest0..s(1O1O3'#,,1O1O1O1O1O1Orc,g|]}t|Sr9ru)r$r?s rr:z _sqrtdenest0..s===1|A===r)ras_numer_denomrrZr-r)rVr,r lenr4_sqrtdenest_recrnrrr _sqrtdenest1 isinstancer^r[ _sqrt_ratcombrfunc)rr>dr,csrzrxr?s rrErEst}}""$$1 ::v} Mafk/?@@@t99q==S(I(ID(I(I(I%I%I=.q1112HS*I*ID*I*I*I%JKKLL%% %44aV444DAqQ3J$ + 9  C##%%DAq IIaLLL KKNNNN ))b))) ) ) +c1O1O$1O1O1O.O.O + T** *$?y  ?49=====> > KsB B*)B*c2ddlm}m}m}|jst |S|jdkr2tdtt|j zS||j\}}}|t|z}||kr||}}t|dz|dzz }t|j dkr||\}}} |t|z}|| kr| |} }t|dz| dzz } tt| } tt|| z} || | \} }t| tdz | |tdzz z}ntt|}t|dkrt||z}t|j t|j kr,t|t|jkrtt t|}t|dkrt|||\} }|tdz | |tdzz z}||}t|S)alHelper that denests the square root of three or more surds. Explanation =========== It returns the denested expression; if it cannot be denested it throws SqrtdenestStopIteration Algorithm: expr.base is in the extension Q_m = Q(sqrt(r_1),..,sqrt(r_k)); split expr.base = a + b*sqrt(r_k), where `a` and `b` are on Q_(m-1) = Q(sqrt(r_1),..,sqrt(r_(k-1))); then a**2 - b**2*r_k is on Q_(m-1); denest sqrt(a**2 - b**2*r_k) and so on. See [1], section 6. Examples ======== >>> from sympy import sqrt >>> from sympy.simplify.sqrtdenest import _sqrtdenest_rec >>> _sqrtdenest_rec(sqrt(-72*sqrt(2) + 158*sqrt(5) + 498)) -sqrt(10) + sqrt(2) + 9 + 9*sqrt(5) >>> w=-6*sqrt(55)-6*sqrt(35)-2*sqrt(22)-2*sqrt(14)+2*sqrt(77)+6*sqrt(10)+65 >>> _sqrtdenest_rec(sqrt(w)) -sqrt(11) - sqrt(7) + sqrt(2) + 3*sqrt(5) r)radsimprad_rationalizerKr6r)rSrrrKrrIr-rr~rr}r,rr"rnr )rrrrKgr?r@c2rBric2_1c_1d_1numdenrxacrrbs rr~r~sr4MLLLLLLLLL ; $ y1}}BxxdiZ(8(89999k$)$$GAq! $q'' A1uu!1 !Q$A+  B 27||aKOO 2r QZ 77BAA &&d4jj))d28nn--"?2s++S Sa[3DGG #44 5 5 b " "!}}q%% QB 27||s49~~%% R==Idi00 0 0) )488A!}}q%%q!$$HC $q'' CT!WW%%A A A;;rTcVddlm}t|s|S|j}|jr|St |}|s|S|\}}}t |dz|dz|zz }|jr|jrt||||}||Snvt | |z} t| } | jr7tt ||z||| }||t|dz Snt|||}||S|rt|s|St|||||} | r| S||||g} t||dzg| dt!|d}| d|S|Dt!|t!|kr"t#|t#|kr|S|S|S)zcReturn denested expr after denesting with simpler methods or, that failing, using the denester.rrr6Nr)sympy.simplify.simplifyrrr-r(rlrrrP_sqrt_numeric_denestrr _sqrt_symbolic_denestr2sqrt_biquadratic_denest _denesterr"r ) rdenesterrr?valr@rbd2rHdr2drr_av0s rrrAs0///// 4==  Ay a..C  GAq! !Q$Aa- B ~ > ($Q1b11A} B3q5//CcB~ ((!A#1cBB=T!QZZ<' "!Q * * =H <-- !$1a 4 4C   aB-C7747##$c1j.>.>??BA 1v~ } a==Jt,, , ,1 $1O1OK Krctt|||f\}}}t|}|sdS|\}}}|r(tdd} t |t ||dz|z |z |}n#t$rYdSwxYw|dkr| \} } } | |z } t| dzd| z| zz  drkt | t || d| zz zdzz} | j r3ttj| } | SdSdSdS)a4Given an expression, sqrt(a + b*sqrt(b)), return the denested expression or None. Explanation =========== If r = ra + rb*sqrt(rr), try replacing sqrt(rr) in ``a`` with (y**2 - ra)/rb, and if the result is a quadratic, ca*y**2 + cb*y + cc, and (cb + b)**2 - 4*ca*cc is 0, then sqrt(a + b*sqrt(r)) can be rewritten as sqrt(ca*(sqrt(r) + (cb + b)/(2*ca))**2). Examples ======== >>> from sympy.simplify.sqrtdenest import _sqrt_symbolic_denest, sqrtdenest >>> from sympy import sqrt, Symbol >>> from sympy.abc import x >>> a, b, r = 16 - 2*sqrt(29), 2, -10*sqrt(29) + 55 >>> _sqrt_symbolic_denest(a, b, r) sqrt(11 - 2*sqrt(29)) + sqrt(5) If the expression is numeric, it will be simplified: >>> w = sqrt(sqrt(sqrt(3) + 1) + 1) + 1 + sqrt(2) >>> sqrtdenest(sqrt((w**2).expand())) 1 + sqrt(2) + sqrt(1 + sqrt(1 + sqrt(3))) Otherwise, it will only be simplified if assumptions allow: >>> w = w.subs(sqrt(3), sqrt(x + 3)) >>> sqrtdenest(sqrt((w**2).expand())) sqrt((sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2))**2) Notice that the argument of the sqrt is a square. If x is made positive then the sqrt of the square is resolved: >>> _.subs(x, Symbol('x', positive=True)) sqrt(sqrt(sqrt(x + 3) + 1) + 1) + 1 + sqrt(2) NyT)positiver6rr)maprrlr rsubsrrdegree all_coeffsrequals is_numberrr\as_content_primitive) r?r@rbrvalrarbrrrnewacacbccrHs rrr|sT'Aq!9%%GAq! q>>D tJBB  # % % % tBxx!Q$)R88!< 0$ If it cannot be denested, it returns ``None``. rr6rN)rr"rrexpand) r?r@rbrrss1s2r_s rrrs RA AA !}}z!}}q(((QT,>(a$q''B >>>>r>>>>>KBDQKK"tAE{{"22d1gg=Azz|| )(rc ddlm}m}|dks |dks|rt|jdkrdS|||fD]#}|jD]}|dz} | jr| jsdS$ttt||} t| dkrdS|dz | dz z|dz | dz z g\} } | | fD]}tt|} t| dkr2||td| z\}}||z }| |t|zz}|dkr| }t|cSdS)adenest expr = sqrt(a + b*sqrt(r)) where a, b, r are linear combinations of square roots of positive rationals on the rationals (SQRR) and r > 0, b != 0, d2 = a**2 - b**2*r > 0 If it cannot denest it returns None. Explanation =========== Search for a solution A of type SQRR of the biquadratic equation 4*A**4 - 4*a*A**2 + b**2*r = 0 (1) sqd = sqrt(a**2 - b**2*r) Choosing the sqrt to be positive, the possible solutions are A = sqrt(a/2 +/- sqd/2) Since a, b, r are SQRR, then a**2 - b**2*r is a SQRR, so if sqd can be denested, it is done by _sqrtdenest_rec, and the result is a SQRR. Similarly for A. Examples of solutions (in both cases a and sqd are positive): Example of expr with solution sqrt(a/2 + sqd/2) but not solution sqrt(a/2 - sqd/2): expr = sqrt(-sqrt(15) - sqrt(2)*sqrt(-sqrt(5) + 5) - sqrt(3) + 8) a = -sqrt(15) - sqrt(3) + 8; sqd = -2*sqrt(5) - 2 + 4*sqrt(3) Example of expr with solution sqrt(a/2 - sqd/2) but not solution sqrt(a/2 + sqd/2): w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3) expr = sqrt((w**2).expand()) a = 4*sqrt(6) + 8*sqrt(2) + 47 + 28*sqrt(3) sqd = 29 + 20*sqrt(3) Define B = b/2*A; eq.(1) implies a = A**2 + B**2*r; then expr**2 = a + b*sqrt(r) = (A + B*sqrt(r))**2 Examples ======== >>> from sympy import sqrt >>> from sympy.simplify.sqrtdenest import _sqrt_match, sqrt_biquadratic_denest >>> z = sqrt((2*sqrt(2) + 4)*sqrt(2 + sqrt(2)) + 5*sqrt(2) + 8) >>> a, b, r = _sqrt_match(z**2) >>> d2 = a**2 - b**2*r >>> sqrt_biquadratic_denest(z, a, b, r, d2) sqrt(2) + sqrt(sqrt(2) + 2) + 2 r)rrr6Nr) rSrrr"r-r,r3rPrrIr)rr?r@rbrrrr%ry2sqdrjx2ABnBdBrHs rrrs`@???????AvvaqJty$9$9A$=$=tAY  AAB=  ttt   :d772;;//00 1 1C#tcCEk1Q3Q; 'FB"X   tAww   a==1    HQqSMM22B rE $q'' M q55A{{ 4rc  ddlm}||krdS|ddS|dtdDrtt D]t t fdtt D}ddkr dr| }t|}|j r|fcStddgt zfSd|d#|dd g}|d |d g}d|d<nttdd D}|D])} | d r| d krd|d<dS!| d *(tddgt zfSfd |Dgz}t|||dz|\} sdStfd tt Ds8|d} t| dt | d| zzfSt fdtt D}t|} dvrYdt dz kr0t dz r| d | d<| d | d<t st | d| z} | dkr(tddgt zfSt#| t#dzks| d zjsd|d<dSt't| d} t#| t#dzksd|d<dS|d| z } t | td z | dtz| ztd z z}|fSt | dz| z}|dkr(tddgt zfSt)t dt|}}t |td |zz | d|ztd |zz zfS)aDenests a list of expressions that contain nested square roots. Explanation =========== Algorithm based on . It is assumed that all of the elements of 'nested' share the same bottom-level radicand. (This is stated in the paper, on page 177, in the paragraph immediately preceding the algorithm.) When evaluating all of the arguments in parallel, the bottom-level radicand only needs to be denested once. This means that calling _denester with x arguments results in a recursive invocation with x+1 arguments; hence _denester has polynomial complexity. However, if the arguments were evaluated separately, each call would result in two recursive invocations, and the algorithm would have exponential complexity. This is discussed in the paper in the middle paragraph of page 179. rr)NNrNc3$K|] }|jV dSr )rT)r$r>s rr&z_denester..6s$,, ,,,,,,rc0g|]}| |Sr9r9r$rGfnesteds rr:z_denester..8s&HHHQ1Q4HvayHHHrrr6r7c,g|]}t|Sr9)rl)r$rs rr:z_denester..Hs 'M'M'Md D(9(9'M'M'Mrcxg|]6}t|ddzt|ddzzz 7S)rr6r)r)r$rcRs rr:z_denester..TsU<<.Ys'44A1Q4444444rc0g|]}| |Sr9r9rs rr:z_denester..]s&DDDAqtDfQiDDDrF)rr)rrr4r=r}rrrDcountrrrWfilterranyrlindexr"rTrr )rrhmax_depth_levelrr/sqpvaluesnested2rcrvadsqvadsqvad1r_rFRrrrs` @@rrrs.0/////?z 1v~z A ,,V,,, , , #f++&&  AHHHHH%A--HHHIJJAwwqzzA~~!B%~Bq''C Av  F2J!S[[00  q6 "1"gYFAA1vqkGCFF&'M'Mf'M'M'MNNOOF ! !Q4!}!99%)CF#-::%aDyF2J''!S[[88<<<<4:<<>1 :4444s6{{!3!344444! Ir A!x!Q///00!3 3DDDDDs6{{););DDDEAAAAvv!''!**s6{{Q661S[[1_;M6!u!!u!S[[> Iqtax((!88r ++aSV_<<!#*Q--!*;;;Q)<!CF%:$T#YY???"5))Z]]Q->>>!CF%: 5))uT!WW}!T!WW V0CDGG0KLMMAv ad1f%%)77r ++aSV_<<Xa[[!,,d2hhA4772:1b$q''!)1D DEEqHHrcHddlm}d}||}|!tdt||DS|\}}}||}||||} ||xx|||z| jz z cc<t ||S)a#Denest rational combinations of radicals. Based on section 5 of [1]. Examples ======== >>> from sympy import sqrt >>> from sympy.simplify.sqrtdenest import sqrtdenest >>> z = sqrt(1+sqrt(3)) + sqrt(3+3*sqrt(3)) - sqrt(10+6*sqrt(3)) >>> sqrtdenest(z) 0 rrcBt|}t|dz D]|}t|dz|D]f}||j}||j}t||z}t t |}|t |kr |||fccSg}dS)Nr)r}rDr-rrIr)r?r>rGjrrr/rs rfindz_sqrt_ratcomb..finds FFq1u # #A1q5!__ # #qTYqTYR"W%%tAww''Q<<a7NNNNN  # # #rNcg|] \}}||z Sr9r9)r$rxrzs rr:z!_sqrt_ratcomb..s 999CQW999r)rSrrziprYr-r) rr,rrindicesri1i2rrBs rrr}s/..... # # #d4jjG993r4==999::IAr2 BHHRLLL bBrFFFggb1frw&'''FFF T " ""rN)r7)T)& sympy.corerrrrrsympy.core.functionrr r sympy.core.sortingr sympy.core.symbolr sympy.functionsr rr sympy.polysrrrintr"r2r=rIrl StopIterationrnrEr~rrrrrrr9rrrs11111111111111??????????//////######,,,,,,,,,,--------LLL  S    :8   :!!!!HLLL^     m   """J===@8888v<<<~(GGGTaIaIaIH)#)#)#)#)#r