o 8VaT@sdZddlmZddlmZmZmZmZmZm Z m Z m Z m Z m Z mZmZddlmZmZddlmZddlmZddlmZddlmZmZmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&m'Z'ddl(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHddlImJZJddlKmLZLddlMmNZNmOZOmPZPmQZQddlRmSZSmTZTe'ddfddZUd d!ZVd"d#ZWdZd%d&ZXd'd(ZYd)d*ZZd[d+d,Z[d-d.Z\d/d0Z]d1d2Z^d3d4Z_d5d6Z`d7d8Zad9d:Zbd;d<ZcePd\d?d@ZddAdBZeedZfdCdDZgdEdFZhePd[d>d>dGdHdIZidJdKZjdLdMZkdNdOZlePd=dPdQdRZmePd[d$dSdTdUZnGdVdWdWeHeEZoePd]dXdYZpd$S)^z&Computational algebraic field theory. )reduce) SRationalAlgebraicNumber GoldenRatioTribonacciConstantAddMulsympifyDummy expand_mulIpi)sqrtcbrt)Factors)_mexpand)exp)cossintan)sieve)divisors)subsets)dup_eval)ZZQQ)dup_chebyshevt)IsomorphismFailed NotAlgebraicGeneratorsError) PolyPurePolyinvert factor_listgroebner resultantdegreepoly_from_exprparallel_poly_from_exprlcm)dict_from_exprexpr_from_dict)rs_compose_add)ring)CRootOfcyclotomic_poly) LambdaPrinter)PythonCodePrinter MpmathPrinter) _split_gcd _is_sum_surds)numbered_symbolslambdifypublicsift)pslqmpcsFddlmt|dtrdd|D}t|dkr|dSdit|dr*|jng}|kr||js6|n|ifdd|D}t t |t|d d D]D}t ||D]\} } | | <qWfd dt |D} t fd d | DrxqPt| } | dd\\} }\}}|| dkr||SqPd9|ks0td|)ze Return a factor having root ``v`` It is assumed that one of the factors has root ``v``. rillegalcSsg|]}|dqS)r.0frBrB:/usr/lib/python3/dist-packages/sympy/polys/numberfields.py 8z"_choose_factor.. symbolscsg|] }|qSrB)as_exprZxreplacerC)xvrBrFrGCT)kZ repetitioncs(g|]\}}t||fqSrB)abssubsn)rDirE)pointsprec1rBrFrGKsc3s|] \}}|vVqdSNrB)rDrS_r@rBrF Psz!_choose_factor..Ni@Bz4multiple candidates for the minimal polynomial of %s)sympy.polys.polyutilsrA isinstancetuplelenhasattrrK is_numberrRrrangezip enumerateanysortedNotImplementedError)factorsxvdomZprecZboundrKZferRsrSZ candidatesZcanaZixbrWrB)rArTrUrMrF_choose_factor0s6       rmcCsddlm}dd}g}|jD]J}|jsB||r#|tj|dfn|jr/||tjfn|jr?|j j r?||tjfnt q||j|dd\}}|t |t |dfq|j dd d |d d tjurm|Sd d|D}tt|D] }||d krnqzt||d\} } } g} g} |D]\}}|| vr| ||tjq| ||tjqt| }t| }t|dt|d}|S)a7 helper function for ``_minimal_polynomial_sq`` It selects a rational ``g`` such that the polynomial ``p`` consists of a sum of terms whose surds squared have gcd equal to ``g`` and a sum of terms with surds squared prime with ``g``; then it takes the field norm to eliminate ``sqrt(g)`` See simplify.simplify.split_surds and polytools.sqf_norm. Examples ======== >>> from sympy import sqrt >>> from sympy.abc import x >>> from sympy.polys.numberfields import _separate_sq >>> p= -x + sqrt(2) + sqrt(3) + sqrt(7) >>> p = _separate_sq(p); p -x**2 + 2*sqrt(3)*x + 2*sqrt(7)*x - 2*sqrt(21) - 8 >>> p = _separate_sq(p); p -x**4 + 4*sqrt(7)*x**3 - 32*x**2 + 8*sqrt(7)*x + 20 >>> p = _separate_sq(p); p -x**8 + 48*x**6 - 536*x**4 + 1728*x**2 - 400 r)r;cSs|jo|jtjuSrV)is_PowrrHalf)exprrBrBrFis_sqrt|sz_separate_sq..is_sqrtrYT)binarycSs|dS)NrIrB)zrBrBrFsz_separate_sq..)keyrIcSsg|]\}}|qSrBrB)rDyrsrBrBrFrGrHz _separate_sq..N)sympy.utilities.iterablesr;argsis_MulappendrOneis_Atomrnr is_integerrer sortr`r]r5rorr)pr;rqrkrwTFZsurdsrSgZb1Zb2Za1Za2rsp1p2rBrBrF _separate_sqasD    rcCsddlm}t|}t|}|jr|dkr||sdS|td|}||8} t|}||ur9||||i}n|}q'|dkr[t|}||| |dkrS| }| d}|St |d}t |||}|S)a Returns the minimal polynomial for the ``nth-root`` of a sum of surds or ``None`` if it fails. Parameters ========== p : sum of surds n : positive integer x : variable of the returned polynomial Examples ======== >>> from sympy.polys.numberfields import _minimal_polynomial_sq >>> from sympy import sqrt >>> from sympy.abc import x >>> q = 1 + sqrt(2) + sqrt(3) >>> _minimal_polynomial_sq(q, 3, x) x**12 - 4*x**9 - 4*x**6 + 16*x**3 - 8 rr6NrI) sympy.simplify.simplifyr7r is_IntegerrrrQr!coeffr' primitiver$rm)rrRrgr7ZpnrrfresultrBrBrF_minimal_polynomial_sqs.     rNcCsttt|}|durt|||}|durt|||}n|||i}|turZ|tkrBtdt\}} |t|d} |t|d} n't|||f||\\} } } | | } | }n|t uret |||}nt d|t usq|tkr{t||||gd} n t| | } t| |} t||}t||}|t ur|dks|dkr| St| ||d} | \} }t||||||}| S)a return the minimal polynomial for ``op(ex1, ex2)`` Parameters ========== op : operation ``Add`` or ``Mul`` ex1, ex2 : expressions for the algebraic elements x : indeterminate of the polynomials dom: ground domain mp1, mp2 : minimal polynomials for ``ex1`` and ``ex2`` or None Examples ======== >>> from sympy import sqrt, Add, Mul, QQ >>> from sympy.polys.numberfields import _minpoly_op_algebraic_element >>> from sympy.abc import x, y >>> p1 = sqrt(sqrt(2) + 1) >>> p2 = sqrt(sqrt(2) - 1) >>> _minpoly_op_algebraic_element(Mul, p1, p2, x, QQ) x - 1 >>> q1 = sqrt(y) >>> q2 = 1 / y >>> _minpoly_op_algebraic_element(Add, q1, q2, x, QQ.frac_field(y)) x**2*y**2 - 2*x*y - y**3 + 1 References ========== .. [1] https://en.wikipedia.org/wiki/Resultant .. [2] I.M. Isaacs, Proc. Amer. Math. Soc. 25 (1970), 638 "Degrees of sums in a separable field extension". NXrzoption not availablegensrIdomain)r str_minpoly_composerQrrr.r+r)composerLr _mulyrer&r-r,Z as_expr_dictr'r!r$rm)opex1ex2rgrimp1mp2rwRrrrrWrZmp1aZdeg1Zdeg2rfresrBrBrF_minpoly_op_algebraic_elements: $       rcs6t|d}t|fdd|D}t|S)z@ Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))`` rcs"g|] \\}}||qSrBrBrDrScrRrgrBrFrG0s"z_invertx..r(r'termsr)rrgrrkrBrrF_invertx)srcs8t|d}t|fdd|D}t|S)z8 Returns ``_mexpand(y**deg*p.subs({x:x / y}))`` rcs*g|]\\}}|||qSrBrBrrRrgrwrBrFrG;s*z_muly..r)rrgrwrrkrBrrFr4src Cst|}|s t|||}|jstd||dkr5||kr#td|t||}|dkr.|S| }d|}tt|}|||i}| \}}t t ||||||gd||d}| \} } t | ||||}|S)a Returns ``minpoly(ex**pw, x)`` Parameters ========== ex : algebraic element pw : rational number x : indeterminate of the polynomial dom: ground domain mp : minimal polynomial of ``p`` Examples ======== >>> from sympy import sqrt, QQ, Rational >>> from sympy.polys.numberfields import _minpoly_pow, minpoly >>> from sympy.abc import x, y >>> p = sqrt(1 + sqrt(2)) >>> _minpoly_pow(p, 2, x, QQ) x**2 - 2*x - 1 >>> minpoly(p**2, x) x**2 - 2*x - 1 >>> _minpoly_pow(y, Rational(1, 3), x, QQ.frac_field(y)) x**3 - y >>> minpoly(y**Rational(1, 3), x) x**3 - y *%s doesn't seem to be an algebraic elementrz %s is zerorvrIrr)r r is_rationalrZeroDivisionErrorrr rrQZas_numer_denomr!r&r$rmrL) exZpwrgrir=rwrRdrrWrfrBrBrF _minpoly_pow?s(      & rc GsZtt|d|d||}|d|d}|ddD]}tt|||||d}||}q|S)z. returns ``minpoly(Add(*a), dom, x)`` rrIrYNr)rrrgrirkr=rZpxrBrBrF _minpoly_addt  rc GsZtt|d|d||}|d|d}|ddD]}tt|||||d}||}q|S)z. returns ``minpoly(Mul(*a), dom, x)`` rrIrYNr)rr rrBrBrF _minpoly_mulrrc s(|jd\}tur|jr|jt}|jr.ttt fddt DS|j dkrK|dkrKdddd d d d Sd dkrwttfd dt dDt }t |\}}t ||}|Sdtd |td tj}t|t}|Std|)zt Returns the minimal polynomial of ``sin(ex)`` see http://mathworld.wolfram.com/TrigonometryAngles.html rcs$g|]}|d|qS)rIrBrDrSrkrRrgrBrFrG$z _minpoly_sin..rI @`$rYc g|] }||qSrBrBrrrBrFrG r)ry as_coeff_Mulrrqr is_primerrrr`rr$rmrrrorrr) rrgrrrrWrfrrprBrrF _minpoly_sins,  (      rc s6ddlm}|jd\}tur|jr|jdkrD|jdkr2ddddddS|jd krCddd dSn!|jdkret|j}|j ret |}t | |ddiSt |jttfd d tdDtd |j}t|\}}t||} | Std|)zt Returns the minimal polynomial of ``cos(ex)`` see http://mathworld.wolfram.com/TrigonometryAngles.html r)rrIrrrYrrcrrBrBrrrBrFrGrz _minpoly_cos..rvr)sympyrryrrrrrr rrrrQintrrr`rr$rmr) rrgrrrrjrrWrfrrBrrF _minpoly_coss.   $         rc Cs|jd\}}|turf|jrf|d}t|j}|jddkr"|nd}g}t|jdd|ddD] }|||||||d|| |d|d}q3t |}t |\}} t | ||} | St d|)zk Returns the minimal polynomial of ``tan(ex)`` see https://github.com/sympy/sympy/issues/21430 rrYrIr) ryrrrrrrr`r{rr$rmr) rrgrrkrRrrOrrWrfrrBrBrF _minpoly_tans ,   rc sR|jd\}}t|j}|ttkr|jr|jdks!|jdkr|dkr-ddS|dkr7ddS|dkrEdddS|dkrOddS|d kr]dddS|d krsdddddS|jrd}t |D] }| |7}q||Sfd d t d|D}t ||}|St d |t d |)z7 Returns the minimal polynomial of ``exp(ex)`` rrIrvrrYrrrrrJcsg|]}t|qSrBr0rrgrBrFrGsz _minpoly_exp..r) ryrr rr rrrrr`rrmr) rrgrrkrrjrSrfr=rBrrF _minpoly_exps6    $    rcCs:|j}||jjd|i}t||\}}t|||}|S)zA Returns the minimal polynomial of a ``CRootOf`` object. r)rprQpolyrr$rm)rrgrrWrfrrBrBrF_minpoly_rootofs  rc s|jr |j||jS|tur,t|dd||d\}}t|dkr(|ddS|tS|tur[t|d|d||d\}}t|dkrM|d|dSt||dtdd|dS|t urt|d|d|d||d\}}t|dkr|d|d|dSdt ddtdt ddtdd}t||||dSt |d r||j vr||S|j rt|r||8} t|}||ur|S|}q|jrt||g|jR}|S|jrlt|j}t|d d } | d r`|tkr`td d| d| dD}t| d } dd| D} tt| dtj} | | tj!} fdd| D}t|}t"||}|j||j| | }| | |t#d}t$t||||||d}|St%||g|jR}|S|j&r{t'|j(|j)||}|S|j*t+urt,||}|S|j*t-urt.||}|S|j*t/urt0||}|S|j*t)urt1||}|S|j*t2urt3||}|St4d|)a Computes the minimal polynomial of an algebraic element using operations on minimal polynomials Examples ======== >>> from sympy import minimal_polynomial, sqrt, Rational >>> from sympy.abc import x, y >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=True) x**2 - 2*x - 1 >>> minimal_polynomial(sqrt(y) + 1/y, x, compose=True) x**2*y**2 - 2*x*y - y**3 + 1 rYrIrr?)rir!rKcSs|djo |djS)NrrI) is_Rational)ZitxrBrBrFrtOrHz"_minpoly_compose..TcSsg|]\}}||qSrBrB)rDZbxrrBrBrFrGQz$_minpoly_compose..FNcSg|]}|jqSrB)r)rDrwrBrBrFrGScs$g|]\}}||j|jqSrB)rr)rDbaserwZlcmdensrBrFrGWr)rrr)5rrrr r$r]rrmrrrr^rKis_QQr7ris_Addrryrzrrfr;itemsrr dictvaluesrr*rZ NegativeOnepopZZerominimal_polynomialrrrrnrrr __class__rrrrrrrr/rr)rrgrirWrfZfacrrrErZr1ZdensZneg1Zexpn1ZnumsrrrrBrrFrs  & 0&           rTFc CsVddlm}ddlm}ddlm}t|}|jrt|dd}||D] }|j r,d}nq#|dur9t|t }} nt d t }} |sP|j rN|tt|j }nt}t|d rb||jvrbtd ||f|rt|||} | d } | ||| |} | jrt| } |r| | |dd S| |S|jstdt||| } |r| | |dd S| |S)a- Computes the minimal polynomial of an algebraic element. Parameters ========== ex : Expr Element or expression whose minimal polynomial is to be calculated. x : Symbol, optional Independent variable of the minimal polynomial compose : boolean, optional (default=True) Method to use for computing minimal polynomial. If ``compose=True`` (default) then ``_minpoly_compose`` is used, if ``compose=False`` then groebner bases are used. polys : boolean, optional (default=False) If ``True`` returns a ``Poly`` object else an ``Expr`` object. domain : Domain, optional Ground domain Notes ===== By default ``compose=True``, the minimal polynomial of the subexpressions of ``ex`` are computed, then the arithmetic operations on them are performed using the resultant and factorization. If ``compose=False``, a bottom-up algorithm is used with ``groebner``. The default algorithm stalls less frequently. If no ground domain is given, it will be generated automatically from the expression. Examples ======== >>> from sympy import minimal_polynomial, sqrt, solve, QQ >>> from sympy.abc import x, y >>> minimal_polynomial(sqrt(2), x) x**2 - 2 >>> minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2))) x - sqrt(2) >>> minimal_polynomial(sqrt(2) + sqrt(3), x) x**4 - 10*x**2 + 1 >>> minimal_polynomial(solve(x**3 + x + 3)[0], x) x**3 + x + 3 >>> minimal_polynomial(sqrt(y), x) x**2 - y rr') FractionField)preorder_traversalT) recursiveFNrgrKz5the variable %s is an element of the ground domain %srI)Zfieldz!groebner method only works for QQ)sympy.polys.polytoolsr'sympy.polys.domainsrZsympy.core.basicrr r_ris_AlgebraicNumberr!r r"Z free_symbolsrlistr^rKr rrrZ is_negativer Zcollectrre_minpoly_groebner) rrgrpolysrr'rrrpclsrrrBrBrFrusB 6        rcsddlm}ddlm}tdtdiidfdd fd d d d }d }||}|jr>|jS|j rJ|j |j }nb||}|rT|d}d}|j rld|j jrld|j } t|j| }n t|rwt|tj}|dur}|}|dur|} | gt} t| tgdd} t| d\} }t||}|rt|}|||dkrt| }|S)a/ Computes the minimal polynomial of an algebraic number using Groebner bases Examples ======== >>> from sympy import minimal_polynomial, sqrt, Rational >>> from sympy.abc import x >>> minimal_polynomial(sqrt(2) + 3*Rational(1, 3), x, compose=False) x**2 - 2*x - 1 rr)expand_multinomialrk)rNcs>t}||<|dur||||<|S|||<|SrV)nextrL)rrrrk) generatormappingrKrBrFupdate_mappingsz)_minpoly_groebner..update_mappingcsz|jr|tjur|vr|ddS|S|jr|Sn|jr+tfdd|jDS|jr:tfdd|jDS|j r|j jr|j dkrlt |j }t |}||j }|j dkrf|S||j }|j js|j |j jtd|j j}}n|j |j }}|}||}|vr|d|| S|Sn|jr|jvr|j|jS|jStd|) NrYrIcg|]}|qSrBrBrDrbottom_up_scanrBrFrGrHz=_minpoly_groebner..bottom_up_scan..crrBrBrrrBrFrGrHrrvz)%s doesn't seem to be an algebraic number)r}rZ ImaginaryUnitrrrryrzr rnrrrr#rLrQexpandrrrrrrootminpolyr)rZ minpoly_baseZinverseZbase_invrrrp)rrrrKrrgrBrFrsH        z)_minpoly_groebner..bottom_up_scancSst|jrd|jjr|jdkr|jjrdS|jr8d}|jD]}|jr$dS|jr3|jjr3|jdkr3dSq|r8dSdS)z Returns True if it is more likely that the minimal polynomial algorithm works better with the inverse rIrTF)rnrr~rrrzry)rZhitrrBrBrFsimpler_inverse s  z*_minpoly_groebner..simpler_inverseFrvrIZlex)ZorderrV)rr'sympy.core.functionrr8r rrrLrrrrnrrrrr7rr|rrr%r$rmrrr )rrgrr'rrinvertedrrrRZbusrGrWrfrB)rrrrrKrrgrFrsF     ,     rcCs*|j}|j|dd}|||jdS)NT)Zfrontr)repZinjectZejectnewr)rKZfrepZhreprBrBrF_switch_domain^s rcCs|jj\}}| |SrVr)rrrrBrBrF _linsolvehs  r)rrcs|std|durt|t}}ntdt}}|sa|ddg}}t||dd}|ddD]"}t||d\} } t| ||}|\} } }|| |7}| | q0|s[| |fS|||fS|ddg}}t||dd} t | |fj g} |ddD]W}t||dd}t ||f}t| |d \} } t| ||} | \} }} || |7}| | t | |ft|}t||}j | |fd d | D|g} qd d | D}|s| ||fS| ||fS) z4Construct a common number field for all extensions. z3can't compute primitive element for empty extensionNrgrrITr extensionrcsg|] }t|jqSrB)rrrDrWrZogenrBrFrGrNz%primitive_element..cSrrBrrrBrBrFrGr) ValueErrorr r!r r"rr$rmZsqf_normr{rLrZalgebraic_fieldZunitrrZgcd)rrgrrrgencoeffsrextrWrfrjrEZrepsrLhZerepHrBrrFprimitive_elementnsL          rc Cs|j}|j}||dkrdS||krdS|j}|j}d|||d}}} t|} | |} | |kr> dS|| drJ|| sJdS|d7}q/)z5Returns `True` if there is a chance for isomorphism. rFTrIrY)rr'Z discriminantr) rkrlrRmdaZdbrSrOZhalfrPrBrBrFis_isomorphism_possibles&     r cs|jjr|jjs td|j}|j|j}d|jd}}}tddD]}|j|}|j|dgfddtd|D|g} t j |} t _ t | t d d d | t _ duradS|krh}ndSfd ddd Dd s d r|ttt|jdd} || |jrtdd} } tD]\}}| || |7} q|| dkrddDSS|| |jrddDS|d9}q&dS)z2Construct field isomorphism using PSLQ algorithm. z)PSLQ doesn't support complex coefficientsdNrIr?csg|]}|qSrBrBr)BrBrFrGrHz*field_isomorphism_pslq..rYg _Bi)ZmaxcoeffZmaxstepscsg|] }t|dqS)rv)rrDr)rrBrFrGsrvrrrcSg|]}| qSrBrBrrBrBrFrGrcSrrBrBrrBrBrFrGr)ris_realrerreplacerr'r`evalfr=dpsr<rrrreversedr!rZremZis_zeror]rb)rkrlrErrRr prevrSAZbasisrrrZapproxrrB)rrrFfield_isomorphism_pslqsH  &   rc Cst|j|d\}}|D]V\}}|dkra|j}t|dg}}t|D]\}} || |j ||q)t |} |j | j dddkrM|S|j | j dddkradd|DSq dS) z/Construct field isomorphism via factorization. rrIT)ZchoprcSrrBrBrrBrBrFrGrz,field_isomorphism_factor..N) r$rr'rZTCZ to_sympy_listr]rbr{rrr) rkrlrWrfrErrrrSrrrBrBrFfield_isomorphism_factors  r)fastcCst|t|}}|jst|}|jst|}||kr|S|j}|j}|dkr1|jgS||dkr9dS|rSzt||}|durH|WSWn tyRYnwt ||S)z4Construct an isomorphism between two number fields. rIrN) r rrrrr'rrrer)rkrlrrRr rrBrBrFfield_isomorphism s.      rrcCst|dr t|}n|g}t|dkr!t|dtur!t|dSt||dd\}}tddt||D}|dur@t||fSt |}|j sMt||d }t ||}|dur[t||St d ||j f) z7Express `extension` in the field generated by `theta`. __iter__rIrTrcSsg|]\}}||qSrBrB)rDrrrBrBrFrG<rz#to_number_field..Nrz%s is not in a subfield of %s)r^rr]typer\rrsumrar rrrr)rZthetarrrrrBrBrFto_number_field0s$        r csDeZdZdZfddZfddZfddZfdd ZZS) IntervalPrinterz?Use ``lambda`` printer but print numbers as ``mpi`` intervals. cdtt||SNz mpi('%s'))superr3_print_IntegerselfrprrBrFr%RzIntervalPrinter._print_Integercr"r#r$r3_print_Rationalr&r(rBrFr+Ur)zIntervalPrinter._print_Rationalcr"r#r*r&r(rBrF _print_HalfXr)zIntervalPrinter._print_Halfcstt|j|ddS)NT)Zrational)r$r4 _print_Powr&r(rBrFr-[r)zIntervalPrinter._print_Pow) __name__ __module__ __qualname____doc__r%r+r,r- __classcell__rBrBr(rFr!Os    r!c Cst|}|jr ||fS|jstdtd|dtd}t|dd}|jdd}tj d}}z(|sQ|}|D]\}} ||j krG|j | krGd}nq5tj d 9_ |r0W|t_ n|t_ w|d uri|j || ||d \}} || fS) zsz 8        0       1A 8O 5  & $ \ _ 26"