a khl@s@dZddlmZddlmZddlmZddlmZm Z m Z ddl m Z ddl mZmZmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZddlm Z m!Z!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZIe)ddfddZJdd ZKd!d"ZLd#d$ZMdFd&d'ZNd(d)ZOd*d+ZPdGd,d-ZQd.d/ZRd0d1ZSd2d3ZTd4d5ZUd6d7ZVd8d9ZWd:d;ZXd/z"_choose_factor.. symbolscsg|]}|iqSr5)as_exprZxreplacer6)vxr5r9r:9r;csg|]}|qSr5)nr6)precr5r9r:;r;T)kZ repetitioncs(g|] \}}t||fqSr5)abssubsrB)r7ir8)pointsprec1r5r9r:Cscss|]\}}|tvVqdSN)r )r7rG_r5r5r9 Hr;z!_choose_factor..Ni@Bz4multiple candidates for the minimal polynomial of %s) isinstancetuplelenhasattrr> is_numberrrangezip enumerateanysortedNotImplementedError)factorsrAr@domrCboundr>ZferBsrG candidatesZcanaixbrKr5)rHrCrIr@rAr9_choose_factor(s2      racCstddt|DS)NcssD|]<}t|D],}|jp8|jo8|jjo8d|jjo8|jVqqdS)rMN)r make_args is_Rationalis_Powbaser is_IntegerZis_extended_real)r7tr8r5r5r9rLYs  z _is_sum_surds..)allrrb)pr5r5r9 _is_sum_surdsXsrjcCsdd}g}|jD]}|jsx||r:|tj|dfq|jrR||tjfq|jrr|jjrr||tjfqt qt |j|dd\}}|t |t |dfq|j ddd|d d tjur|Sd d |D}t t|D]}||d krqqd dlm}|||d\} } } g} g} |D]>\}}|| vrT| ||tjn| ||tjq,t| }t| }t|dt|d}|S)a? 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.minpoly 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 cSs|jo|jtjuSrJ)rdrr Half)exprr5r5r9is_sqrtxsz_separate_sq..is_sqrtrMT)binarycSs|dS)Nr<r5)zr5r5r9r;z_separate_sq..)keyr<cSsg|] \}}|qSr5r5)r7yror5r5r9r:r;z _separate_sq..r) _split_gcdN)argsis_Mulappendr Oneis_Atomrdr is_integerrXr2rsortrSrPZsympy.simplify.radsimprtrkrr)rirmr^rsTFZsurdsrGrtgb1b2Za1Za2rop1p2r5r5r9 _separate_sq^s@     rcCst|}t|}|jr&|dkr&t|s*dS|td|}||8}t|}||urf||||i}qlq@|}q@|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.minpoly 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 rNr<) rrfrjr rrFrcoeffr% primitiver"ra)rirBrAZpnrrYresultr5r5r9_minimal_polynomial_sqs(   rNcCsztt|}|dur t|||}|dur6t|||}n|||i}|tur|tkrtdt\}} |t|d} |t|d} qt|||f||\\} } } | | } | }n|t urt |||}nt d|t us|tkrt||||gd} nt| | } t| |} t||}t||}|t ur6|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.minpoly 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 availablegensr<domain)rstr_minpoly_composerFrrr,r)r'composer?r_mulyrXr$r+r*Z as_expr_dictr%rr"ra)opex1ex2rArZmp1mp2rsRrrrrKrZmp1aZdeg1Zdeg2rYresr5r5r9_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|]\\}}||qSr5r5r7rGcrBrAr5r9r:+r;z_invertx..r&r%termsr)rirArr^r5rr9_invertx$srcs8t|d}t|fdd|D}t|S)z8 Returns ``_mexpand(y**deg*p.subs({x:x / y}))`` rcs*g|]"\\}}|||qSr5r5rrBrArsr5r9r:6r;z_muly..r)rirArsrr^r5rr9r/src 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.minpoly 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 does not seem to be an algebraic elementrz %s is zerorrr<rr)rr is_rationalrZeroDivisionErrorrrrrFZas_numer_denomrr$r"rar?) expwrArZmprsrBdrrKrYr5r5r9 _minpoly_pow:s(      & rc GsZtt|d|d||}|d|d}|ddD] }tt|||||d}||}q4|S)z. returns ``minpoly(Add(*a), dom, x)`` rr<rMNr)rrrArZr^rriZpxr5r5r9 _minpoly_addos  rc GsZtt|d|d||}|d|d}|ddD] }tt|||||d}||}q4|S)z. returns ``minpoly(Mul(*a), dom, x)`` rr<rMNr)rrrr5r5r9 _minpoly_mul{s  rc s0|jd\}tur |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)zu Returns the minimal polynomial of ``sin(ex)`` see https://mathworld.wolfram.com/TrigonometryAngles.html rcs$g|]}|d|qS)r<r5r7rGr^rBrAr5r9r:r;z _minpoly_sin..r< @`$rMcs g|]}||qSr5r5rrr5r9r:r;rN)ru as_coeff_Mulr rqris_primerrrrSrir"rarr rkrrr) rrArrrrKrYrrlr5rr9 _minpoly_sins,   (     rc s2|jd\}tur"|jr"|jdkr|jdkr\ddddddS|jdkrddd dSnB|jdkrt|j}|jrt|}t | t ddiSt |jt tfd d tdDtd |j}t|\}}t||}|Std |dS)zu Returns the minimal polynomial of ``cos(ex)`` see https://mathworld.wolfram.com/TrigonometryAngles.html rr<rrrMrrcs g|]}||qSr5r5rrr5r9r:r;z _minpoly_cos..rrrN)rurr rrirrrrrrFrintrrrSrr"rar) rrArrr\rrKrYrr5rr9 _minpoly_coss*   $        rc Cs|jd\}}|tur|jr|d}t|j}|jddkrD|nd}g}t|jdd|ddD]@}|||||||d|| |d|d}qft |}t |\}} t | ||} | St d|dS)zk Returns the minimal polynomial of ``tan(ex)`` see https://github.com/sympy/sympy/issues/21430 rrMr<rN) rurr rrrrirSrwrr"rar) rrArr^rBrrDrrKrYrr5r5r9 _minpoly_tans ,  rc s`|jd\}}|ttkrP|jrDt|j}|jdksH|jdkr|dkr`ddS|dkrtddS|dkrdddS|dkrddS|d krdddS|d krdddddS|jrd}t |D]}| |7}q|Sfd d t d|D}t ||}|St d |t d |dS)z7 Returns the minimal polynomial of ``exp(ex)`` rr<rrrrMrrrrr=csg|]}t|qSr5r.rrAr5r9r:r;z _minpoly_exp..rN) rurr r rrrrirrSrrar) rrArr^rr\rGrYrr5rr9 _minpoly_exps6   $   rcCs:|j}||jjd|i}t||\}}t|||}|S)zA Returns the minimal polynomial of a ``CRootOf`` object. r)rlrFZpolyrr"ra)rrArirKrYrr5r5r9_minpoly_rootofs  rc s|jr|j||jS|turXt|dd||d\}}t|dkrP|ddS|tS|tjurt|d|d||d\}}t|dkr|d|dSt||dt dd|dS|tj urPt|d|d|d||d\}}t|dkr|d|d|dSdt ddt dt ddt dd}t||||dSt |d rp||j vrp||S|jrt|r|}||8}t|}||urtt|d||S|}q|jrt||g|jR}n|jrt|j} t| d d } | d r|tkrtd d| d| dD}t| d } dd| D} tt| dtj} | | tj!}fdd| D}t|}t"||}|j||j| |}| ||t#d}t$t||||||d}nt%||g|jR}n|j&rt'|j(|j)||}n|j*t+ur0t,||}nl|j*t-urHt.||}nT|j*t/ur`t0||}n<|j*t)urxt1||}n$|j*t2urt3||}n t4d||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 rMr<rr4)rZr!r>cSs|djo|djS)Nrr<)rc)Zitxr5r5r9rpJr;z"_minpoly_compose..TcSsg|]\}}||qSr5r5)r7bxrr5r5r9r:Lr;z$_minpoly_compose..FNcSsg|] }|jqSr5)r)r7rsr5r5r9r:Nr;cs$g|]\}}||j|jqSr5)rir)r7rersZlcmdensr5r9r:Rr;)rrr)5rcrrir r"rPr Z GoldenRatiorarZTribonacciConstantrrQr>is_QQrjris_AddrrurvrrYr2itemsrrdictvaluesrr(Z NegativeOnepopZZerominimal_polynomialr rrrdrrer __class__rrrrrrrr-rr)rrArZrKrYZfacr@rrr8rZr1ZdensZneg1Zexpn1numsrrrr5rr9rst    &0                 rTFc Cs8t|}|jrt|dd}t|D]}|jr"d}q6q"|durNt|t}}ntdt}}|s||jrxt t t |j}nt }t |dr||j vrtd||f|rt|||}|d}||t||}|jrt| }|r|||dd S||S|jstd t|||}|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 T) recursiveFNrAr>z5the variable %s is an element of the ground domain %sr<)fieldz!groebner method only works for QQ)rrRrris_AlgebraicNumberrrr Z free_symbolsrrlistrQr>rrrrr%Z is_negativerZcollectrrX_minpoly_groebner) rrArpolysrrlclsrrr5r5r9rps:7      rc s|tdtdiidfdd fdddd }d }t|}|jrf|S|jr~|j|j}n||}|r|d }d}|j rd |j j rd |j }t |j |}nt|rt |tj}|dur|}|durD|}|gt} t| tgd d} t| d \} } t| |}|rxt|}|t|dkrxt| }|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^)rNcs<t}||<|dur*||||<n|||<|SrJ)nextr?)rrrer^) generatormappingr>r5r9update_mappings z)_minpoly_groebner..update_mappingcs|jr<|tjur.|vr$|ddS|Sn |jr8|SnP|jrZtfdd|jDS|jrxtfdd|jDS|j rd|j jr|j dkrt |j }t |}||j }|j dkrԈ|S||j }|j js|j |j jtd|j j}}n|j |j }}|}||}|vrZ|jrF|S|d|| Sn|Sn(|jr|vr||S|Std|d S) a Transform a given algebraic expression *ex* into a multivariate polynomial, by introducing fresh variables with defining equations. Explanation =========== The critical elements of the algebraic expression *ex* are root extractions, instances of :py:class:`~.AlgebraicNumber`, and negative powers. When we encounter a root extraction or an :py:class:`~.AlgebraicNumber` we replace this expression with a fresh variable ``a_i``, and record the defining polynomial for ``a_i``. For example, if ``a_0**(1/3)`` occurs, we will replace it with ``a_1``, and record the new defining polynomial ``a_1**3 - a_0``. When we encounter a negative power we transform it into a positive power by algebraically inverting the base. This means computing the minimal polynomial in ``x`` for the base, inverting ``x`` modulo this poly (which generates a new polynomial) and then substituting the original base expression for ``x`` in this last polynomial. We return the transformed expression, and we record the defining equations for new symbols using the ``update_mapping()`` function. rMr<csg|] }|qSr5r5r7r~bottom_up_scanr5r9r:r;z=_minpoly_groebner..bottom_up_scan..csg|] }|qSr5r5rrr5r9r:r;rrrz*%s does not seem to be an algebraic numberN)ryr Z ImaginaryUnitrcrrrurvrrdrrrer!r?rFexpandrfrir rrminpoly_of_elementr)rZ minpoly_baseZinverseZbase_invrerrl)rrrr>rrAr5r9rsL             z)_minpoly_groebner..bottom_up_scancSst|jr(d|jjr(|jdkr(|jjr(dS|jrpd}|jD].}|jrHdS|jr8|jjr8|jdkr8dSq8|rpdSdS)z Returns True if it is more likely that the minimal polynomial algorithm works better with the inverse r<rTF)rdrrzrerrvru)rhitrir5r5r9simpler_inverse4s z*_minpoly_groebner..simpler_inverseFrrr<lex)orderr)N)r0rrrrr?rcrrirdrrfrrerjr rxrrr#r"rarrr%r) rrArrinvertedrrrBZbusr}GrKrYr5)rrrrr>rrAr9rsB   J     rcCst|||||dS)z6This is a synonym for :py:func:`~.minimal_polynomial`.)rArrr)r)rrArrrr5r5r9minpolyosr)NN)N)NTFN)NTFN)]__doc__ functoolsrZsympy.core.addrZsympy.core.exprtoolsrZsympy.core.functionrrrZsympy.core.mulrZsympy.core.numbersr r r r Zsympy.core.singletonr Zsympy.core.symbolrZsympy.core.sympifyrZsympy.core.traversalrZ&sympy.functions.elementary.exponentialrZ(sympy.functions.elementary.miscellaneousrrZ(sympy.functions.elementary.trigonometricrrrZsympy.ntheory.factor_rZsympy.utilities.iterablesrZsympy.polys.domainsrrrZsympy.polys.orthopolysrZsympy.polys.polyerrorsrrZsympy.polys.polytoolsrr r!r"r#r$r%r&r'r(Zsympy.polys.polyutilsr)r*Zsympy.polys.ring_seriesr+Zsympy.polys.ringsr,Zsympy.polys.rootoftoolsr-Zsympy.polys.specialpolysr/Zsympy.utilitiesr0r1r2rarjrrrrrrrrrrrrrrrrrr5r5r5r9s^            0    0A6 O  5  &$ ] \#