o
     ôj�l  ã                   @   s@  d Z ddlmZ ddlmZ ddlmZ ddlmZm	Z	m
Z
 ddlmZ ddlmZmZmZmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZmZ ddlm Z m!Z!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZE ddlFmGZGmHZHmIZI e)ddfdd„ZJdd „ ZKd!d"„ ZLd#d$„ ZMdFd&d'„ZNd(d)„ ZOd*d+„ ZPdGd,d-„ZQd.d/„ ZRd0d1„ ZSd2d3„ ZTd4d5„ ZUd6d7„ ZVd8d9„ ZWd:d;„ ZXd<d=„ ZYeHdHd@dA„ƒZZdBdC„ Z[eHdHdDdE„ƒZ\d%S )Iz*Minimal polynomials for algebraic numbers.é    )Úreduce)ÚAdd)ÚFactors)Ú
expand_mulÚexpand_multinomialÚ_mexpand)ÚMul)ÚIÚRationalÚpiÚ_illegal)ÚS)ÚDummy)Úsympify)Úpreorder_traversal)Úexp)ÚsqrtÚcbrt)ÚcosÚsinÚtan)Údivisors)Úsubsets)ÚZZÚQQÚFractionField)Údup_chebyshevt)ÚNotAlgebraicÚGeneratorsError)
ÚPolyÚPurePolyÚinvertÚfactor_listÚgroebnerÚ	resultantÚdegreeÚpoly_from_exprÚparallel_poly_from_exprÚlcm)Údict_from_exprÚexpr_from_dict)Úrs_compose_add)Úring)ÚCRootOf©Úcyclotomic_poly)Únumbered_symbolsÚpublicÚsiftéÈ   é   c                    s8  t | d tƒrdd„ | D ƒ} t| ƒdkr| d S d‰i ‰ t|dƒr$|jng }ˆˆkr–‡‡fdd„| D ƒ}ˆjr@‡fdd„|D ƒ}tt|ƒt|ƒd	d
�D ]B}t||ƒD ]\}	}
|
ˆ |	< qR‡ ‡fdd„t	|ƒD ƒ}t
dd„ |D ƒƒrqqKt|ƒ}|dd… \\}}\}}||d kr�| |   S qKˆd9 ‰ˆˆks*tdˆ ƒ‚)ze
    Return a factor having root ``v``
    It is assumed that one of the factors has root ``v``.
    r   c                 S   s   g | ]}|d  ‘qS )r   © ©Ú.0Úfr5   r5   ús/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/sympy/polys/numberfields/minpoly.pyÚ
<listcomp>/   ó    z"_choose_factor.<locals>.<listcomp>é   é
   Úsymbolsc                    s   g | ]}|  ¡  ˆˆ i¡‘qS r5   )Úas_exprÚxreplacer6   )ÚvÚxr5   r9   r:   9   s    c                    s   g | ]}|  ˆ ¡‘qS r5   )Únr6   )Úprecr5   r9   r:   ;   ó    T)ÚkÚ
repetitionc                    s(   g | ]\}}t | ˆ ¡ ˆ¡ƒ|f‘qS r5   )ÚabsÚsubsrC   )r7   Úir8   )ÚpointsÚprec1r5   r9   r:   C   s    ÿc                 s   s   � | ]	\}}|t v V  qd S ©N)r   )r7   rJ   Ú_r5   r5   r9   Ú	<genexpr>H   s   € z!_choose_factor.<locals>.<genexpr>Né   i@B z4multiple candidates for the minimal polynomial of %s)Ú
isinstanceÚtupleÚlenÚhasattrr>   Ú	is_numberr   ÚrangeÚzipÚ	enumerateÚanyÚsortedÚNotImplementedError)ÚfactorsrB   rA   ÚdomrD   Úboundr>   ÚferC   ÚsrJ   Ú
candidatesÚcanÚaÚixÚbrN   r5   )rK   rD   rL   rA   rB   r9   Ú_choose_factor(   s6   
ÿÿãrf   c                 C   s   t dd„ t | ¡D ƒƒS )Nc                 s   sF   � | ]}t  |¡D ]}|jp|jo|jjod |j jo|jV  q	qdS )rP   N)r   Ú	make_argsÚis_RationalÚis_PowÚbaser   Ú
is_IntegerÚis_extended_real)r7   Útr8   r5   r5   r9   rO   Y   s   € 
þþÿ
ÿÿz _is_sum_surds.<locals>.<genexpr>)Úallr   rg   )Úpr5   r5   r9   Ú_is_sum_surdsX   s   þrp   c                 C   s’  dd„ }g }| j D ]I}|js;||ƒr| tj|d f¡ q	|jr)| |tjf¡ q	|jr9|jjr9| |tjf¡ q	t	‚t
|j |dd�\}}| t|Ž t|Ž d f¡ q	|jdd„ d� |d	 d
 tju rf| S dd„ |D ƒ}tt|ƒƒD ]
}|| d
kr} nqsddlm} |||d… Ž \}	}
}g }g }|D ]\}}||
v r¨| ||tj  ¡ q•| ||tj  ¡ q•t|Ž }t|Ž }t|d ƒt|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

    c                 S   s   | j o| jtju S rM   )ri   r   r   ÚHalf)Úexprr5   r5   r9   Úis_sqrtx   s   z_separate_sq.<locals>.is_sqrtrP   T)Úbinaryc                 S   s   | d S )Nr<   r5   )Úzr5   r5   r9   Ú<lambda>‰   s    z_separate_sq.<locals>.<lambda>)Úkeyéÿÿÿÿr<   c                 S   s   g | ]\}}|‘qS r5   r5   )r7   Úyru   r5   r5   r9   r:   �   r;   z _separate_sq.<locals>.<listcomp>r   )Ú
_split_gcdN)ÚargsÚis_MulÚappendr   ÚOneÚis_Atomri   r   Ú
is_integerr[   r2   r   ÚsortrV   rS   Úsympy.simplify.radsimprz   rq   r   r   )ro   rs   rc   ry   ÚTÚFÚsurdsrJ   rz   ÚgÚb1Úb2Úa1Úa2ru   Úp1Úp2r5   r5   r9   Ú_separate_sq^   sB   
ÿr�   c                 C   sÆ   t | ƒ} t |ƒ}|jr|dkrt| ƒsdS | td|ƒ }| |8 } 	 t| ƒ}|| u r3| ||| i¡} n|} q!|dkrUt| ƒ}|  || |¡ ¡dk rM|  } |  	¡ d } | S t
| ƒ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

    r   Nr<   )r   rk   rp   r
   r�   rI   r   Úcoeffr%   Ú	primitiver"   rf   )ro   rC   rB   Úpnr‹   r\   Úresultr5   r5   r9   Ú_minimal_polynomial_sqŸ   s,   úr’   Nc                 C   st  t t|ƒƒ}|du rt|||ƒ}|du rt|||ƒ}n| ||i¡}| tu rZ|tkrBtdtƒ\}}	|t|ƒd ƒ}
|t|ƒd ƒ}n't||| f||ƒ\\}
}}|
 	|¡}| 
¡ }n| tu ret|||ƒ}ntdƒ‚| tu sq|tkr{t||||gd�}nt|
|ƒ}t| ¡ |ƒ}t||ƒ}t||ƒ}| tu r™|dks�|dkrŸ|S t|||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".

    NÚXr   zoption not available©Úgensr<   ©Údomain)r   ÚstrÚ_minpoly_composerI   r   r   r,   r)   r'   Úcomposer?   r   Ú_mulyr[   r$   r+   r*   Úas_expr_dictr%   r   r"   rf   )ÚopÚex1Úex2rB   r]   Úmp1Úmp2ry   ÚRr“   r‹   rŒ   rN   ÚrZmp1aZdeg1Zdeg2r\   Úresr5   r5   r9   Ú_minpoly_op_algebraic_elementÕ   s:   $




r¥   c                    s6   t | ˆƒd }t|ƒ‰ ‡ ‡fdd„| ¡ D ƒ}t|Ž S )z@
    Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
    r   c                    s"   g | ]\\}}|ˆˆ |   ‘qS r5   r5   ©r7   rJ   Úc©rC   rB   r5   r9   r:   +  s   " z_invertx.<locals>.<listcomp>©r&   r%   Útermsr   )ro   rB   r‹   rc   r5   r¨   r9   Ú_invertx$  s   r«   c                    s8   t | ˆƒd }t|ƒ‰ ‡ ‡‡fdd„| ¡ D ƒ}t|Ž S )z8
    Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
    r   c                    s*   g | ]\\}}|ˆ|  ˆˆ |   ‘qS r5   r5   r¦   ©rC   rB   ry   r5   r9   r:   6  s   * z_muly.<locals>.<listcomp>r©   )ro   rB   ry   r‹   rc   r5   r¬   r9   r›   /  s   r›   c                 C   sÜ   t |ƒ}|st| ||ƒ}|jstd|  ƒ‚|dk r5||kr#td|  ƒ‚t||ƒ}|dkr.|S | }d|  } tt|ƒƒ}| ||i¡}| 	¡ \}}t
t||| ||  |gd�||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 elementr   z
%s is zerorx   r<   r”   r–   )r   r™   Úis_rationalr   ÚZeroDivisionErrorr«   r   r˜   rI   Úas_numer_denomr   r$   r"   rf   r?   )ÚexÚpwrB   r]   Úmpry   rC   Údr¤   rN   r\   r5   r5   r9   Ú_minpoly_pow:  s(   
&rµ   c              	   G   sZ   t t|d |d | |ƒ}|d |d  }|dd… D ]}t t||| ||d�}|| }q|S )z.
    returns ``minpoly(Add(*a), dom, x)``
    r   r<   rP   N©r    )r¥   r   ©rB   r]   rc   r³   ro   Úpxr5   r5   r9   Ú_minpoly_addo  ó   
r¹   c              	   G   sZ   t t|d |d | |ƒ}|d |d  }|dd… D ]}t t||| ||d�}|| }q|S )z.
    returns ``minpoly(Mul(*a), dom, x)``
    r   r<   rP   Nr¶   )r¥   r   r·   r5   r5   r9   Ú_minpoly_mul{  rº   r»   c           	         s(  | j d  ¡ \}‰ ˆ tu rŽ|jrŽ|j‰tˆƒ}|jr.tˆtƒ‰ t	‡ ‡‡fdd„t
ˆƒD ƒŽ S |jdkrK|dkrKdˆd  dˆd	   d
ˆd   d S ˆd dkrwtˆtƒ‰ ‡ ‡‡fdd„t
ˆd ƒD ƒ‰ t	ˆ Ž }t|ƒ\}}t|ˆ| ƒ}|S dtd| t ƒ d tj }t|ˆtƒ}|S td|  ƒ‚)zu
    Returns the minimal polynomial of ``sin(ex)``
    see https://mathworld.wolfram.com/TrigonometryAngles.html
    r   c                    s$   g | ]}ˆˆ| d   ˆ |  ‘qS )r<   r5   ©r7   rJ   ©rc   rC   rB   r5   r9   r:   –  ó   $ z _minpoly_sin.<locals>.<listcomp>r<   é	   é@   é   é`   é   é$   rP   é   c                    ó    g | ]}ˆˆ|  ˆ |  ‘qS r5   r5   r¼   r½   r5   r9   r:      ó     r­   )r{   Úas_coeff_Mulr   r®   Úqr   Úis_primer   r   r   rV   ro   r"   rf   r   r   rq   r™   r   r   )	r±   rB   r§   rÉ   r£   rN   r\   r¤   rr   r5   r½   r9   Ú_minpoly_sin‡  s,   

(
rË   c           	         s*  | j d  ¡ \}‰ ˆ tu r�|jr�|jdkr>|jdkr,dˆd  dˆd   dˆ  d S |jdkr=dˆd  d	ˆ  d S n!|jdkr_t|jƒ}|jr_t| ˆƒ}t	| 
ˆtdˆ d ƒi¡ƒS t|jƒ‰tˆtƒ‰ ‡ ‡‡fd
d„tˆd ƒD ƒ‰ tˆ Ž d|j  }t|ƒ\}}t|ˆ| ƒ}|S td|  ƒ‚)zu
    Returns the minimal polynomial of ``cos(ex)``
    see https://mathworld.wolfram.com/TrigonometryAngles.html
    r   r<   é   é   rÅ   rÃ   rP   r¿   rÁ   c                    rÆ   r5   r5   r¼   r½   r5   r9   r:   Ã  rÇ   z _minpoly_cos.<locals>.<listcomp>rx   r­   )r{   rÈ   r   r®   ro   rÉ   r   rÊ   rË   r   rI   r   Úintr   r   rV   r   r"   rf   r   )	r±   rB   r§   rÉ   r`   r£   rN   r\   r¤   r5   r½   r9   Ú_minpoly_cos­  s,   

$
ÿ




rÏ   c                 C   sØ   | j d  ¡ \}}|tu rf|jrf|d }t|jƒ}|jd dkr"|nd}g }t|jd d |d dƒD ] }| |||  ¡ ||| d  ||   |d |d   }q3t	|Ž }t
|ƒ\}}	t|	|| ƒ}
|
S td|  ƒ‚)zk
    Returns the minimal polynomial of ``tan(ex)``
    see https://github.com/sympy/sympy/issues/21430
    r   rP   r<   r­   )r{   rÈ   r   r®   rÎ   rÉ   ro   rV   r}   r   r"   rf   r   )r±   rB   r§   rc   rC   rª   rF   r£   rN   r\   r¤   r5   r5   r9   Ú_minpoly_tanÌ  s   
,rÐ   c           	         sR  | j d  ¡ \}}|tt kr£|jr�t|jƒ}|jdks!|jdkrˆ|dkr-ˆ d ˆ  d S |dkr7ˆ d d S |dkrEˆ d ˆ d  d S |dkrOˆ d d S |d	kr]ˆ d ˆ d  d S |d
krsˆ d ˆ d  ˆ d  ˆ d  d S |jrˆd}t	|ƒD ]	}|ˆ  | 7 }q||S ‡ fdd„t
d| ƒD ƒ}t|ˆ | ƒ}|S td|  ƒ‚td|  ƒ‚)z7
    Returns the minimal polynomial of ``exp(ex)``
    r   r<   rx   rÅ   rP   rÃ   rÁ   rÍ   r¿   r=   c                    s   g | ]}t |ˆ ƒ‘qS r5   r.   r¼   ©rB   r5   r9   r:      rE   z _minpoly_exp.<locals>.<listcomp>r­   )r{   rÈ   r	   r   r®   r   rÉ   ro   rÊ   rV   r   rf   r   )	r±   rB   r§   rc   rÉ   r`   rJ   r\   r³   r5   rÑ   r9   Ú_minpoly_expä  s6   
$rÒ   c                 C   s:   | j }| | jjd |i¡}t||ƒ\}}t||| ƒ}|S )zA
    Returns the minimal polynomial of a ``CRootOf`` object.
    r   )rr   rI   Úpolyr•   r"   rf   )r±   rB   ro   rN   r\   r‘   r5   r5   r9   Ú_minpoly_rootof  s
   rÔ   c              	      sœ  | j r| j| | j S | tu r,t|d d ||d�\}}t|ƒdkr(|d d S |t S | tju r\t|d | d ||d�\}}t|ƒdkrN|d | d S t||dt	dƒ d |d�S | tj
u r¦t|d |d  | d ||d�\}}t|ƒdkr†|d |d  | d S dtddt	dƒ  ƒ tddt	dƒ  ƒ d }t||||d�S t|d	ƒr´| |jv r´||  S |jr×t| ƒr×| }| |8 } 	 t| ƒ}|| u rÔtt| ƒd ||ƒS |} qÂ| jræt||g| j¢R Ž }|S | j�rxt| ƒj}	t|	 ¡ d
d„ ƒ}
|
d �rl|tk�rltdd„ |
d |
d  D ƒŽ }t|
d ƒ}dd„ | ¡ D ƒ}tt|dƒ‰ tj}|  |tj!¡}‡ fdd„| ¡ D ƒ}t|Ž }t"||ƒ}|j|ˆ   |j||ˆ     }|| |t#dˆ ƒ  }t$t||||||d�}|S t%||g| j¢R Ž }|S | j&�r‡t'| j(| j)||ƒ}|S | j*t+u �r”t,| |ƒ}|S | j*t-u �r¡t.| |ƒ}|S | j*t/u �r®t0| |ƒ}|S | j*t)u �r»t1| |ƒ}|S | j*t2u �rÈt3| |ƒ}|S t4d|  ƒ‚)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

    rP   r<   r–   r4   )r]   rÅ   é   é!   r>   c                 S   s   | d j o	| d j S )Nr   r<   )rh   )Zitxr5   r5   r9   rv   J  r;   z"_minpoly_compose.<locals>.<lambda>Tc                 S   s   g | ]\}}|| ‘qS r5   r5   )r7   Úbxr±   r5   r5   r9   r:   L  s    z$_minpoly_compose.<locals>.<listcomp>FNc                 S   s   g | ]}|j ‘qS r5   )rÉ   )r7   ry   r5   r5   r9   r:   N  s    c                    s$   g | ]\}}||j ˆ  |j  ‘qS r5   )ro   rÉ   )r7   rj   ry   ©Zlcmdensr5   r9   r:   R  r¾   )r    r¡   r­   )5rh   rÉ   ro   r	   r"   rS   r   ÚGoldenRatiorf   r   ÚTribonacciConstantr   rT   r>   Úis_QQrp   r�   Úis_Addr¹   r{   r|   r   r\   r2   Úitemsr   r   ÚdictÚvaluesr   r(   ÚNegativeOneÚpopÚZeroÚminimal_polynomialr
   r¥   r»   ri   rµ   rj   r   Ú	__class__r   rË   r   rÏ   r   rÐ   rÒ   r-   rÔ   r   )r±   rB   r]   rN   r\   ÚfacrA   rž   r¤   r8   r£   Úr1ZdensZneg1Zexpn1ÚnumsrŸ   r    r¡   r5   rØ   r9   r™     sˆ    

&0û&Û

 ñòô
ö
	ø
ú
ü
ÿr™   TFc           	      C   s2  t | ƒ} | jrt| dd�} t| ƒD ]	}|jrd} nq|dur't |ƒt}}ntdƒt}}|s>| jr<t	t
t| jƒƒ}nt
}t|dƒrP||jv rPtd||f ƒ‚|r~t| ||ƒ}| ¡ d }| |t||ƒ ¡}|jrpt| ƒ}|ry|||dd	�S | |¡S |js…td
ƒ‚t| ||ƒ}|r”|||dd	�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)Ú	recursiveFNrB   r>   z5the variable %s is an element of the ground domain %sr<   )Úfieldz!groebner method only works for QQ)r   rU   r   r   Úis_AlgebraicNumberr   r   r    Úfree_symbolsr   r   ÚlistrT   r>   r   r™   r�   rŽ   r%   Úis_negativer   ÚcollectrÛ   r[   Ú_minpoly_groebner)	r±   rB   rš   Úpolysr—   rr   Úclsr‘   r§   r5   r5   r9   rã   p  s<   7þÿ
rã   c                    sv  t dtd�‰i i ‰‰d‡‡‡fdd„	‰‡ ‡‡‡‡‡fdd„‰ dd	„ }d
}t| ƒ} | jr3|  ¡  ˆ¡S | jr?| jˆ | j }nb|| ƒ}|rI| d } d}| j	rad| j
 jrad| j
 }t| j|ˆƒ}nt| ƒrlt| tjˆƒ}|durr|}|du r¡ˆ | ƒ}ˆ| gtˆ ¡ ƒ }	t|	tˆ ¡ ƒˆg dd�}
t|
d ƒ\}}t|ˆ| ƒ}|r¹t|ˆƒ}| ˆt|ˆƒ ¡dk r¹t| ƒ}|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   )rñ   Nc                    s>   t ˆ ƒ}|ˆ| < |d ur|| | ˆ| < |S | |¡ˆ| < |S rM   )Únextr?   )r±   r   rj   rc   )Ú	generatorÚmappingr>   r5   r9   Úupdate_mappingß  s   þz)_minpoly_groebner.<locals>.update_mappingc                    s„  | j r| tju r| ˆvrˆ| ddƒS ˆ|  S | jr| S n | jr+t‡ fdd„| jD ƒŽ S | jr:t‡ fdd„| jD ƒŽ S | j	rª| j
jr©| j
dk rlt| jˆˆƒ}tˆ|ƒ ¡ }| ˆ| j¡ ¡ }| j
dkrfˆ |ƒS || j
  } | j
js‚| j| j
j  ¡ td| j
jƒ}}n| j| j
}}ˆ |ƒ}|| }|ˆvr¥|jrœ| ¡ S ˆ|d| | ƒS ˆ| S n| jr¼| ˆvr¸ˆ| |  ¡ ƒS ˆ|  S td|  ƒ‚)	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.

        rP   r<   c                    ó   g | ]}ˆ |ƒ‘qS r5   r5   ©r7   r†   ©Úbottom_up_scanr5   r9   r:     r;   z=_minpoly_groebner.<locals>.bottom_up_scan.<locals>.<listcomp>c                    rö   r5   r5   r÷   rø   r5   r9   r:     r;   r   rx   z*%s does not seem to be an algebraic number)r   r   ÚImaginaryUnitrh   rÜ   r   r{   r|   r   ri   r   rï   rj   r!   r?   rI   Úexpandrk   ro   r
   rÉ   rê   Úminpoly_of_elementr   )r±   Zminpoly_baseÚinverseZbase_invrj   r   rr   )rù   rñ   rô   r>   rõ   rB   r5   r9   rù   ê  sL   
ÿ

ÿèz)_minpoly_groebner.<locals>.bottom_up_scanc                 S   st   | j rd| j jr| jdk r| jjrdS | jr8d}| jD ]}|jr$ dS |j r3|jjr3|jdkr3 dS q|r8dS dS )z
        Returns True if it is more likely that the minimal polynomial
        algorithm works better with the inverse
        r<   r   TF)ri   r   r€   rj   rÜ   r|   r{   )r±   Úhitro   r5   r5   r9   Úsimpler_inverse4  s    
€z*_minpoly_groebner.<locals>.simpler_inverseFrx   r<   Úlex)Úorderr   rM   )r0   r   r   rê   rü   r?   rh   rÉ   ro   ri   r   rk   r’   rj   rp   r   r~   rì   rß   r#   r"   rf   r«   rŽ   r%   r   )r±   rB   rñ   rÿ   Úinvertedr‘   r¤   rC   Zbusr„   ÚGrN   r\   r5   )rù   rñ   ró   rô   r>   rõ   rB   r9   rï   Í  sB   
J


rï   c                 C   s   t | ||||d�S )z6This is a synonym for :py:func:`~.minimal_polynomial`.)rB   rš   rð   r—   )rã   )r±   rB   rš   rð   r—   r5   r5   r9   Úminpolyo  s   r  )NNrM   )NTFN)]Ú__doc__Ú	functoolsr   Zsympy.core.addr   Zsympy.core.exprtoolsr   Úsympy.core.functionr   r   r   Zsympy.core.mulr   Úsympy.core.numbersr	   r
   r   r   Zsympy.core.singletonr   Úsympy.core.symbolr   Úsympy.core.sympifyr   Úsympy.core.traversalr   Ú&sympy.functions.elementary.exponentialr   Ú(sympy.functions.elementary.miscellaneousr   r   Ú(sympy.functions.elementary.trigonometricr   r   r   Úsympy.ntheory.factor_r   Úsympy.utilities.iterablesr   Úsympy.polys.domainsr   r   r   Úsympy.polys.orthopolysr   Úsympy.polys.polyerrorsr   r   Úsympy.polys.polytoolsr   r    r!   r"   r#   r$   r%   r&   r'   r(   Úsympy.polys.polyutilsr)   r*   Zsympy.polys.ring_seriesr+   Úsympy.polys.ringsr,   Úsympy.polys.rootoftoolsr-   Úsympy.polys.specialpolysr/   Zsympy.utilitiesr0   r1   r2   rf   rp   r�   r’   r¥   r«   r›   rµ   r¹   r»   rË   rÏ   rÐ   rÒ   rÔ   r™   rã   rï   r  r5   r5   r5   r9   Ú<module>   s`    00A
6O
5&$]\ #