B [j@sdZddlmZmZddlmZmZmZmZm Z m Z m Z m Z m Z mZddlmZddlmZmZddlmZmZmZmZmZmZmZmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$ddl%m&Z&dd l'm(Z(dd l)m*Z*m+Z+dd l,m-Z-m.Z.dd l/m0Z0dd l1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBddlCmDZDddlEmFZFddlGmHZHddlImJZJmKZKddlLmMZMddlLmNZNe.ddfddZOddZPd d!ZQdRd#d$ZRd%d&ZSd'd(ZTdSd)d*ZUd+d,ZVd-d.ZWd/d0ZXd1d2ZYd3d4ZZd5d6Z[d7d8Z\e;dTd;d<Z]d=d>Z^e]Z_e`ad?d@dAZbe;dUdBdCZcdDdEZddFdGZedHdIZfe;dJdKZge;dVdLdMZhGdNdOdOe6Zie;dWdPdQZjd"S)Xz&Computational algebraic field theory. )print_functiondivision) SRationalAlgebraicNumberAddMulsympifyDummy expand_mulIpi)exp)cossin) PolyPurePolysqf_norminvert factor_listgroebner resultantdegreepoly_from_exprparallel_poly_from_exprlcm)IsomorphismFailedCoercionFailed NotAlgebraicGeneratorsError)CRootOf)cyclotomic_poly)dict_from_exprexpr_from_dict)ZZQQ)dup_chebyshevt)ring)rs_compose_add) LambdaPrinter)numbered_symbols variationslambdifypublicsift)Factors)_mexpand) _split_gcd) _is_sum_surds)sieve)divisors)pslqmp)reduce)rangecCst|dtrdd|D}t|dkr0|dS||i}t|drH|jng}tdd}xt|t|D]} d} | } x |D]} | ||| <| |} qzWxrg} || d}x.|D]&}t| | ||kr| |qW| r| }t|dkr|dS| |krP| d9} qWqhWt d|d S) ze Return a factor having root ``v`` It is assumed that one of the factors has root ``v``. rcSsg|] }|dqS)r).0fr;r;7lib/python3.7/site-packages/sympy/polys/numberfields.py ?sz"_choose_factor..symbols z4multiple candidates for the minimal polynomial of %sN) isinstancetuplelenhasattrrAr%r8absas_exprevalfappendNotImplementedError)factorsxvdomZprecZboundZpointsrAtnZprec1Zn_tempsZ candidatesepsr=r;r;r>_choose_factor9s6        rUcCsddlm}dd}g}x|jD]}|js||rH|tj|dfq |jr`||tjfq |jr|j j r||tjfq t q ||j|dd\}}|t |t |dfq W|j dd d |d d tjkr|Sd d|D}x"tt|D]}||d krPqWt||d\} } } g} g} xF|D]>\}}|| kr\| ||tjn| ||tjq4Wt| }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|jtjkS)N)is_PowrrHalf)exprr;r;r>is_sqrtzsz_separate_sq..is_sqrtrCT)ZbinarycSs|dS)Nr@r;)zr;r;r>sz_separate_sq..)keyr@cSsg|] \}}|qSr;r;)r<yrZr;r;r>r?sz _separate_sq..N)Zsympy.utilities.iterablesr.argsis_MulrKrOneis_AtomrVr is_integerrLrsortr8rFr1rWrr0)pr.rYar^TFZsurdsigZb1Zb2Za1Za2rZp1p2r;r;r> _separate_sq_sB    rmc Csddlm}t|}t|}||}|jr:|dkr:||s>dS|td|}||8}x.t|}||kr|||||i}PqV|}qVW|dkrt|}||| |dkr| }| 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 r)r2Nr@) sympy.simplify.simplifyr2r is_Integerrrmsubsrcoeffr primitiverrU) rerRrNr2rZpnrkrMresultr;r;r>_minimal_polynomial_sqs.    ruNcCsztt|}|dkr t|||}|dkr6t|||}n|||i}|tkr|tkrtdt\}} |t|d} |t|d} qt|||f||\\} } } | | } | }n|t krt |||}nt d|t ks|tkrt||||gd} nt| | } t| |} t||}t||}|t kr6|dks@|dkrD| 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] http://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 available)gensr@)domain)r str_minpoly_composerprr%r'r"rcomposerIr_mulyrLrr(r#Z as_expr_dictrrrrU)opex1ex2rNrPmp1mp2r^Rrvrkrl_rsZmp1aZdeg1Zdeg2rMresr;r;r>_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|]\\}}||qSr;r;)r<ric)rRrNr;r>r?.sz_invertx..)rrtermsr)rerNrkrfr;)rRrNr>_invertx'srcs8t|d}t|fdd|D}t|S)z8 Returns ``_mexpand(y**deg*p.subs({x:x / y}))`` rcs*g|]"\\}}|||qSr;r;)r<rir)rRrNr^r;r>r?9sz_muly..)rrrr)rerNr^rkrfr;)rRrNr^r>r|2sr|c Cst|}|st|||}|js*td||dkrj||krFtd|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 z*%s doesn't seem to be an algebraic elementrz %s is zeror]r@)rw)rx)r rz is_rationalrZeroDivisionErrorrr ryrpZas_numer_denomrrrrUrI) exZpwrNrPr6r^rRdrrrMr;r;r> _minpoly_pow=s(      & rc Gs^tt|d|d||}|d|d}x0|ddD] }tt|||||d}||}q6W|S)z. returns ``minpoly(Add(*a), dom, x)`` rr@rCN)r)rr)rNrPrfr6repxr;r;r> _minpoly_addrs  rc Gs^tt|d|d||}|d|d}x0|ddD] }tt|||||d}||}q6W|S)z. returns ``minpoly(Mul(*a), dom, x)`` rr@rCN)r)rr)rNrPrfr6rerr;r;r> _minpoly_mul~s  rc s0|jd\}tkr |jr |jt}|jr`ttt fddt DS|j dkr|dkrdddd d d d Sd dkrttfd dt dDt }t |\}}t ||}|Sdtd |td tj}t|t}|Std|dS)zt Returns the minimal polynomial of ``sin(ex)`` see http://mathworld.wolfram.com/TrigonometryAngles.html rcs$g|]}|d|qS)r@r;)r<ri)rfrRrNr;r>r?sz _minpoly_sin..r@ @`$rCcs g|]}||qSr;r;)r<ri)rfrRrNr;r>r?sz*%s doesn't seem to be an algebraic elementN)r_ as_coeff_Mulr rqr is_primer&r$rr8rerrUrrrWrzr%r) rrNrrrsrrMrrXr;)rfrRrNr> _minpoly_sins,   (     rc s>ddlm}|jd\}tkr.|jr.|jdkr|jdkrhddddddS|jd krddd dSnB|jdkrt|j}|j rt |}t | |ddiSt |jttfd d tdDtd |j}t|\}}t||} | Std|dS)zt Returns the minimal polynomial of ``cos(ex)`` see http://mathworld.wolfram.com/TrigonometryAngles.html r)sqrtr@rrrCrrcs g|]}||qSr;r;)r<ri)rfrRrNr;r>r?sz _minpoly_cos..r]z*%s doesn't seem to be an algebraic elementN)sympyrr_rr rrerr rrr0rpintr&r$r8rrrUr) rrNrrrrSrsrrMrr;)rfrRrNr> _minpoly_coss,    $        rc sn|jd\}}t|j}t|j}|ttkr^|jrR|jdksR|jdkr(|dkrjddS|dkr~ddS|dkrdddS|dkrddS|d krʈdddS|d krdddddS|jr(d}x t |D]}| |7}q W|Sfd d t d|D}t ||} | St d |t d |dS)z7 Returns the minimal polynomial of ``exp(ex)`` rr@r]rrCrrrrrBcsg|]}t|qSr;)r!)r<ri)rNr;r>r?sz _minpoly_exp..z*%s doesn't seem to be an algebraic elementN) r_rr rerr r rrr8r4rUr) rrNrrfrerrSrirMr6r;)rNr> _minpoly_exps8    $  rcCs:|j}||jjd|i}t||\}}t|||}|S)zA Returns the minimal polynomial of a ``CRootOf`` object. r)rXrppolyrwrrU)rrNrerrMrtr;r;r>_minpoly_rootofs  rc s:|jr|j||jS|tkrXt|dd||d\}}t|dkrP|ddS|tSt|drt||jkrt||S|jrt |r||8}xt |}||kr|S|}qW|j rt ||f|j }nr|jrt|j}t|dd}|dr|tkrtdd |d |d D}|d} d d | D} tt| dfd d | D} t| } t||} | j|| j}| td} tt|| ||| |d}nt||f|j }n|jrt|j|j||}nl|jt krt!||}nT|jt"krt#||}n<|jtkrt$||}n$|jt%kr*t&||}n t'd||S)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 rCr@)rxrAcSs|djo|djS)Nrr@) is_Rational)Zitxr;r;r>r[&sz"_minpoly_compose..TcSsg|]\}}||qSr;r;)r<Zbxrr;r;r>r?(sz$_minpoly_compose..FNcSsg|]\}}|jqSr;)r)r<rr^r;r;r>r?*scs$g|]\}}||j|jqSr;)rer)r<baser^)lcmdensr;r>r?,s)rrz*%s doesn't seem to be an algebraic element)(rrrer rrFrGrAis_QQr2rmis_Addrr_r`r/rMr.itemsr%rr7rminimal_polynomialrrrrVrrr __class__rrrrrr rr)rrNrPrrMr~rr=rsZr1ZdensZnumsrrrr;)rr>rzsV             rzTFc Csbddlm}ddlm}ddlm}t|}|jr>t|dd}x||D]}|j rHd}PqHW|dk rtt|t }} nt d t }} |s|j r|tt|j }nt}t|d r||jkrtd ||f|r(t|||} | d } | ||| |} | jr t| } |r| | |dd S| |S|js8tdt||| } |rX| | |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 r)r) FractionField)preorder_traversalT) recursiveFNrNrAz5the variable %s is an element of the ground domain %sr@)fieldz!groebner method only works for QQ)sympy.polys.polytoolsrsympy.polys.domainsrZsympy.core.basicrr Z is_numberr0is_AlgebraicNumberrr rZ free_symbolsr%listrGrArrzrrrqZ is_negativer ZcollectrrL_minpoly_groebner) rrNr{polysrxrrrrXclsrtrr;r;r>rGs>6         rcsddlm}ddlm}tdtdiig}dfdd fd d d d }d }||}|jr~|j|S|j r|j ||j }n||}|r|d}d} |j rd|j jrd|j } t|j| |} nt|rt|tj|} | dk r| }| dkr^|} || gt} t| t|gdd} 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 r)r)expand_multinomialrf)rNcs<t}||<|dk r*||||<n|||<|S)N)nextrI)rrrrf) generatormappingrAr;r>update_mappings z)_minpoly_groebner..update_mappingc s|jr<|tjkr.|kr$|ddS|Sn |jr8|Snp|jrZtfdd|jDS|jrxtfdd|jDS|j r|j jr|j dkr|j jr|j \}}t |dd\}}|j |}t|j||}||j|}|j d kr|S||j }|j js<|j |j jtd|j j}}n|j |j }}|}||} | krv| d|| S| Sn,|jr|jkr|j|jS|jStd |dS) NrCr@csg|] }|qSr;r;)r<rj)bottom_up_scanr;r>r?sz=_minpoly_groebner..bottom_up_scan..csg|] }|qSr;r;)r<rj)rr;r>r?srT)rr]z)%s doesn't seem to be an algebraic number)rbrZ ImaginaryUnitrrrr_r`rrVrrZ as_coeff_addprimitive_elementrgenrIrpexpandrorerrrrootminpolyr) rrqrZeltralgZinverserrrX)rrrArr;r>rsF        $    z)_minpoly_groebner..bottom_up_scancSsx|jr(d|jjr(|jdkr(|jjr(dS|jrtd}g}x4|jD]*}|jrLdS|jr>|jjr>|jdkr>dSq>W|rtdSdS)z Returns True if it is more likely that the minimal polynomial algorithm works better with the inverse r@rTF)rVrrcrrr`r_)rZhitrfrer;r;r>simpler_inverses  z*_minpoly_groebner..simpler_inverseFr]r@lex)order)N)rrsympy.core.functionrr*r rrrIrrrerVrrorurr2rrarvaluesrrrUrrqr )rrNrrrreplacerinvertedrtrrRZbusrhGrrMr;)rrrrArr>rsF    1       rrccs>x8tddddddg|ddD]}|d d krt|VqWd S) z1Generate coefficients for `primitive_element()`. r@r]rCrT)Z repetitionrN)r+r)rRcoeffsr;r;r>_coeffs_generator6s  rc Ksz|s td|dk r$t|t}}ntdt}}|dds|ddg}}t|trf|j |}nt ||dd }xT|ddD]D}t ||d \}} t | ||}| \} }}|| |7}|| qW|d ds||fS|||fStd td } gg} } x^|D]V}t| }|jr@|jr2||}n td|n t||}| || |q W|dt}x|t| D]}|tddt|| D}t| |g| |gddd}|dd||d|dd}}xZtt|| D]F\}\}}yt|||dd||<Wntk r,PYnXqWPq~Wtd|\}}|d dsl|||fS|||fSdS)z4Construct a common number field for all extensions. z3can't compute primitive element for empty extensionNrNrFrr@T)r) extensionrr^)rz#expected minimal polynomial, got %srcSsg|]\}}||qSr;r;)r<rr^r;r;r>r?ssz%primitive_element..r)rrr]r%)rxz%run out of coefficient configurations) ValueErrorr rr rgetrDrrrrrrUrrKrIr*rZis_PolyZ is_univariaterrFsumzipr enumerateZ all_coeffsr RuntimeErrorZ clear_denoms)rrNr_rrrrjextrrMrSrrhYr^r=Zcoeffs_generatorrHrihr;r;r>r?s^                 rc Cs|j}|j}||dkr$dS||kr0dS|j}|j}d|||d}}}x>t|} | |} | |krxP|| dr|| sdS|d7}q^WdS)z5Returns `True` if there is a chance for isomorphism. rFTr@rC)rrZ discriminantr3) rfbrRmZdaZdbrikZhalfrePr;r;r>is_isomorphism_possibles$      rcs|jjr|jjstd|j}|j|j}d|jd}}}xtddD]p}|j|}|j|dgfddtd|D|g} t j |} t _ t | t d d d | t _ dkrP|kr҈}nPfd ddd Dxd s qWttt|jdd} || |jrtdd} } x*tD]\}}| || |7} qRW|| dkrddDSSqP|| |jrddDS|d9}qPWdS)z2Construct field isomorphism using PSLQ algorithm. z)PSLQ doesn't support complex coefficientsdNr@r:csg|] }|qSr;r;)r<ri)Br;r>r?sz*field_isomorphism_pslq..rCg _Bi)ZmaxcoeffZmaxstepscsg|]}t|dqS)r])r)r<r)rr;r>r?sr]r%)rxrcSsg|] }| qSr;r;)r<rr;r;r>r?scSsg|] }| qSr;r;)r<rr;r;r>r?s)ris_realrLrrrrr8rJr6dpsr5rpoprreversedrr{ZremZis_zerorFr)rfrr=rjrRrprevriAZbasisrrrZapproxrqr;)rrr>field_isomorphism_pslqsB  &    rc Cst|j|d\}}x|D]\}}|dkr|j}t|dg}}x,t|D] \}} || |j ||qVWt |} |j | j dddkr|S|j | j dddkrdd|DSqWdSdS) z/Construct field isomorphism via factorization. )rr@T)ZchoprcSsg|] }| qSr;r;)r<rr;r;r>r?sz,field_isomorphism_factor..N) rrrZrepZTCZ to_sympy_listrFrrKrrrJ) rfrrrMr=rrrrirqrr;r;r>field_isomorphism_factors rcKst|t|}}|js t|}|js.t|}||kr>|S|j}|j}|dkrb|jgS||dkrrdS|ddryt||}|dk r|SWnt k rYnXt ||S)z4Construct an isomorphism between two number fields. r@rNfastT) r rrrrrrrrrLr)rfrr_rRrrtr;r;r>field_isomorphisms*     rcKs|d}t|drt|}n|g}t|dkrLt|dtkrLt|dSt||dd\}}tddt ||D}|d krt||fSt |}|j st||d }t ||}|d k rt||St d ||jfd S) z7Express `extension` in the field generated by `theta`. r__iter__r@rT)rcSsg|]\}}||qSr;r;)r<rqrr;r;r>r?(sz#to_number_field..N)rz%s is not in a subfield of %s)rrGrrFtyperErrrrr rrrr)rZthetar_rrrrr;r;r>to_number_fields$        rcs8eZdZdZfddZfddZfddZZS)IntervalPrinterz?Use ``lambda`` printer but print numbers as ``mpi`` intervals. csdtt||S)Nz mpi('%s'))superr_print_Integer)selfrX)rr;r>r>szIntervalPrinter._print_Integercsdtt||S)Nz mpi('%s'))rr_print_Rational)rrX)rr;r>rAszIntervalPrinter._print_Rationalcstt|j|ddS)NT)Zrational)rr _print_Pow)rrX)rr;r>rDszIntervalPrinter._print_Pow)__name__ __module__ __qualname____doc__rrr __classcell__r;r;)rr>r;s  rc Cst|}|jr||fS|js$tdtd|dtd}t|dd}|jdd}tj d}}zNxH|s|}x8|D]"\}} ||j krn|j | krnd}PqnWtj d 9_ q^WWd |t_ X|d k r|j || ||d \}} || fS) zisolateHs,   r)NN)N)NTFN)N)N)NF)krZ __future__rrrrrrrrr r r r r Z&sympy.functions.elementary.exponentialrZ(sympy.functions.elementary.trigonometricrrrrrrrrrrrrrrZsympy.polys.polyerrorsrrrrZsympy.polys.rootoftoolsr Zsympy.polys.specialpolysr!Zsympy.polys.polyutilsr"r#rr$r%Zsympy.polys.orthopolysr&Zsympy.polys.ringsr'Zsympy.polys.ring_seriesr(Zsympy.printing.lambdareprr)Zsympy.utilitiesr*r+r,r-r.Zsympy.core.exprtoolsr/rr0Zsympy.simplify.radsimpr1rnr2Z sympy.ntheoryr3Zsympy.ntheory.factor_r4rr5r6Zsympy.core.compatibilityr7r8rUrmrurrr|rrrrrrrrzrrr__all__rKrrrrrrrrrr;r;r;r>sp0 4              &A9 N  5  & % G _    K6 #