a Z>m?Z?m@Z@ddlAmBZBddlCmDZDddlEmFZFddlGmHZHddlImJZJddlKmLZLddlMmNZNmOZOmPZPe+dd fd!d"ZQd#d$ZRd%d&ZSdHd(d)ZTd*d+ZUd,d-ZVdId.d/ZWd0d1ZXd2d3ZYd4d5ZZd6d7Z[d8d9Z\d:d;Z]dd?Z_eOdJdBdCZ`dDdEZaeOdKdFdGZbd'S)Lz*Minimal polynomials for algebraic numbers.)reduce)Add) expand_mulexpand_multinomial)Mul) GoldenRatioTribonacciConstant)IRationalpi)S)Dummy)sympify)sqrtcbrt)Factors)_mexpand)preorder_traversal)exp)cossintan)divisors)subsets)ZZQQ FractionField)dup_chebyshevt) NotAlgebraicGeneratorsError) PolyPurePolyinvert factor_listgroebner resultantdegreepoly_from_exprparallel_poly_from_exprlcm)dict_from_exprexpr_from_dictillegal)rs_compose_add)ring)CRootOfcyclotomic_poly) _split_gcd) _is_sum_surds)numbered_symbolspublicsiftcs6t|dtrdd|D}t|dkr0|dSdit|drH|jng}|kr&||jsb|n|ifdd|D}tt|t|dd D]}t ||D]\} } | | <qfd dt |D} t d d | Drqt | } | d d\\} }\}}|| dkr||Sqd9qLt d|d S)ze Return a factor having root ``v`` It is assumed that one of the factors has root ``v``. rcSsg|] }|dqS)r.0fr9r9p/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/polys/numberfields/minpoly.py 5z"_choose_factor.. symbolscsg|]}|qSr9)as_exprZxreplacer:)xvr9r=r>@r?T)kZ repetitioncs(g|] \}}t||fqSr9)abssubsn)r;ir<)pointsprec1r9r=r>Hscss|]\}}|tvVqdSN)r,)r;rI_r9r9r= Mr?z!_choose_factor..Ni@Bz4multiple candidates for the minimal polynomial of %s) isinstancetuplelenhasattrrB is_numberrHrrangezip enumerateanysortedNotImplementedError)factorsxvdomprecboundrBZferHsrI candidatesZcanaixbrMr9)rJrKrDr=_choose_factor.s0      rfcCsdd}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 krqqt||d \}} } g} g} |D]>\}} | | vrH| || 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|jtjuSrL)is_Powrr Half)exprr9r9r=is_sqrtxsz_separate_sq..is_sqrtrOT)binarycSs|dS)Nr@r9)zr9r9r=r?z_separate_sq..)keyr@cSsg|] \}}|qSr9r9)r;yrlr9r9r=r>r?z _separate_sq..N)argsis_Mulappendr Oneis_Atomrgr is_integerrZr6rsortrUrRr2rhrr)prjrcrpTFZsurdsrIgb1b2Za1Za2rlp1p2r9r9r= _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@) r is_Integerr3r rrGr coeffr& primitiver#rf)rxrHr\Zpnr~r[resultr9r9r=_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)r str_minpoly_composerGrrr.r*r(composerCr_mulyrZr%r-r+Z as_expr_dictr&r r#rf)opex1ex2r\r^mp1mp2rpRrr~rrMrZmp1aZdeg1Zdeg2r[resr9r9r=_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|]\\}}||qSr9r9r;rIcrHr\r9r=r>*r?z_invertx..r'r&termsr)rxr\r~rcr9rr=_invertx#srcs8t|d}t|fdd|D}t|S)z8 Returns ``_mexpand(y**deg*p.subs({x:x / y}))`` rcs*g|]"\\}}|||qSr9r9rrHr\rpr9r=r>5r?z_muly..r)rxr\rpr~rcr9rr=r.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 doesn't seem to be an algebraic elementrz %s is zeroror@rr)rr is_rationalrZeroDivisionErrorrr rrGZas_numer_denomr r%r#rfrC) expwr\r^mprprHdrrMr[r9r9r= _minpoly_pow9s(      & rc GsZtt|d|d||}|d|d}|ddD] }tt|||||d}||}q4|S)z. returns ``minpoly(Add(*a), dom, x)`` rr@rONr)rrr\r^rcrrxZpxr9r9r= _minpoly_addns  rc GsZtt|d|d||}|d|d}|ddD] }tt|||||d}||}q4|S)z. returns ``minpoly(Mul(*a), dom, x)`` rr@rONr)rrrr9r9r= _minpoly_mulzs  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)zt Returns the minimal polynomial of ``sin(ex)`` see http://mathworld.wolfram.com/TrigonometryAngles.html rcs$g|]}|d|qS)r@r9r;rIrcrHr\r9r=r>r?z _minpoly_sin..r@ @`$rOcs g|]}||qSr9r9rrr9r=r>r?rN)rq as_coeff_Mulr rqris_primerrrrUrxr#rfrr rhrrr) rr\rrrrMr[rrir9rr= _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)zt Returns the minimal polynomial of ``cos(ex)`` see http://mathworld.wolfram.com/TrigonometryAngles.html rr@rrrOrrcs g|]}||qSr9r9rrr9r=r>r?z _minpoly_cos..rorN)rqrr rrxrrrrrrGrintrrrUrr#rfr) rr\rrrarrMr[rr9rr= _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 rrOr@rN) rqrr rrrrxrUrsrr#rfr) rr\rrcrHrrErrMr[rr9r9r= _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@rorrOrrrrrAcsg|]}t|qSr9r0rr\r9r=r>r?z _minpoly_exp..rN) rqrr r rrrrxrrUrrfr) rr\rrcrrarIr[rr9rr= _minpoly_exps6   $   rcCs:|j}||jjd|i}t||\}}t|||}|S)zA Returns the minimal polynomial of a ``CRootOf`` object. r)rirGZpolyrr#rf)rr\rxrMr[rr9r9r=_minpoly_rootofs  rc s|jr|j||jS|turXt|dd||d\}}t|dkrP|ddS|tS|turt|d|d||d\}}t|dkr|d|dSt||dtdd|dS|t urLt|d|d|d||d\}}t|dkr |d|d|dSdt ddtdt ddtdd}t||||dSt |d rl||j vrl||S|j rt|r||8}t|}||ur|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+urt,||}nl|j*t-ur0t.||}nT|j*t/urHt0||}n<|j*t)ur`t1||}n$|j*t2urxt3||}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 rOr@rr8)r^r!rBcSs|djo|djS)Nrr@) is_Rational)Zitxr9r9r=rmHr?z"_minpoly_compose..TcSsg|]\}}||qSr9r9)r;bxrr9r9r=r>Jr?z$_minpoly_compose..FNcSsg|] }|jqSr9)r)r;rpr9r9r=r>Lr?cs$g|]\}}||j|jqSr9)rxr)r;baserpZlcmdensr9r=r>Pr?)rrr)5rrrxr r#rRrrfrrrrSrBis_QQr3ris_Addrrqrrrr[r6itemsrrdictvaluesrr)r Z NegativeOnepopZZerominimal_polynomialr rrrgrrr __class__rrrrrrrr/rr)rr\r^rMr[Zfacrrr<rZr1ZdensZneg1Zexpn1numsrrrr9rr=rsr   &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) recursiveFNr\rBz5the variable %s is an element of the ground domain %sr@)fieldz!groebner method only works for QQ)rrTrris_AlgebraicNumberr r r!Z free_symbolsrrlistrSrBrrrrr&Z is_negativerZcollectrrZ_minpoly_groebner) rr\rpolysrriclsrrr9r9r=rns: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 rc)rNcs<t}||<|dur*||||<n|||<|SrL)nextrC)rrrrc) generatormappingrBr9r=update_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. rOr@csg|] }|qSr9r9r;r{bottom_up_scanr9r=r> r?z=_minpoly_groebner..bottom_up_scan..csg|] }|qSr9r9rrr9r=r>r?rroz)%s doesn't seem to be an algebraic numberN)rur Z ImaginaryUnitrrrrqrrrrgrrrr"rCrGexpandrrxr rrminpoly_of_elementr)rZ minpoly_baseZinverseZbase_invrrri)rrrrBrr\r9r=rsL             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)rgrrvrrrrrq)rhitrxr9r9r=simpler_inverse2s z*_minpoly_groebner..simpler_inverseFror@lex)orderr)N)r4r rrrrCrrrxrgrrrrr3r rtrrr$r#rfrrr&r) rr\rrinvertedrrrHZbusrzGrMr[r9)rrrrrBrr\r=rsB   J     rcCst|||||dS)z6This is a synonym for :py:func:`~.minimal_polynomial`.)r\rrr)r)rr\rrrr9r9r=minpolymsr)NN)N)NTFN)NTFN)c__doc__ functoolsrZsympy.core.addrZsympy.core.functionrrZsympy.core.mulrZ sympy.corerrZsympy.core.numbersr r r Zsympy.core.singletonr Zsympy.core.symbolr Zsympy.core.sympifyrZsympy.functionsrrZsympy.core.exprtoolsrrZsympy.core.traversalrZ&sympy.functions.elementary.exponentialrZ(sympy.functions.elementary.trigonometricrrrZsympy.ntheory.factor_rZsympy.utilities.iterablesrZsympy.polys.domainsrrrZsympy.polys.orthopolysrZsympy.polys.polyerrorsrrZsympy.polys.polytoolsr r!r"r#r$r%r&r'r(r)Zsympy.polys.polyutilsr*r+r,Zsympy.polys.ring_seriesr-Zsympy.polys.ringsr.Zsympy.polys.rootoftoolsr/Zsympy.polys.specialpolysr1Zsympy.simplify.radsimpr2Zsympy.simplify.simplifyr3Zsympy.utilitiesr4r5r6rfrrrrrrrrrrrrrrrrrr9r9r9r=sd             0      0@6 O  5  &$ \ \#