ó
    Š*£h�l  ã                   ó0  • S r SSKJr  SSKJr  SSKJr  SSKJrJ	r	J
r
  SSKJr  SSKJrJrJrJr  SSKJr  SS	KJr  SS
KJr  SSKJr  SSKJr  SSKJrJr  SSKJ r J!r!J"r"  SSK#J$r$  SSK%J&r&  SSK'J(r(J)r)J*r*  SSK+J,r,  SSK-J.r.J/r/  SSK0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:  SSK;J<r<J=r=  SSK>J?r?  SSK@JArA  SSKBJCrC  SSKDJErE  SSKFJGrGJHrHJIrI  \)SS4S jrJS rKS rLS  rMS1S" jrNS# rOS$ rPS2S% jrQS& rRS' rSS( rTS) rUS* rVS+ rWS, rXS- rY\HS3S. j5       rZS/ r[\HS3S0 j5       r\g!)4z*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           
      ó€  • [        U S   [        5      (       a  U  Vs/ s H  ofS   PM	     n n[        U 5      S:X  a  U S   $ Sn0 n[        US5      (       a  UR                  O/ n	Xt::  Ga3  U  Vs/ s H"  ofR                  5       R                  X05      PM$     n
nUR                  (       a   U
 Vs/ s H  ofR                  U5      PM     n
n[        [        U5      [        U	5      SS9 H¥  n[        X›5       H	  u  pÍXØU'   M     [        U
5       VVs/ s H0  u  pÖ[        UR                  U5      R                  U5      5      U4PM2     nnn[        S U 5       5      (       a  M|  [!        U5      nUSS	 u  u  nnu  nnUUS
-  :”  d  M   U U   s  $    US	-  nXt::  a  GM3  [#        SU-  5      es  snf s  snf s  snf s  snnf )zY
Return a factor having root ``v``
It is assumed that one of the factors has root ``v``.
r   é   é
   ÚsymbolsT)ÚkÚ
repetitionc              3   ó8   #   • U  H  u  pU[         ;   v •  M     g 7f©N)r   )Ú.0ÚiÚ_s      Ú]/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/polys/numberfields/minpoly.pyÚ	<genexpr>Ú!_choose_factor.<locals>.<genexpr>H   s   é € Ð8ªZ¡T Q�1œ–=ªZùs   ‚Né   i@B z4multiple candidates for the minimal polynomial of %s)Ú
isinstanceÚtupleÚlenÚhasattrr8   Úas_exprÚxreplaceÚ	is_numberÚnr   ÚrangeÚzipÚ	enumerateÚabsÚsubsÚanyÚsortedÚNotImplementedError)ÚfactorsÚxÚvÚdomÚprecÚboundÚfÚprec1Úpointsr8   ÚferK   Úsr>   Ú
candidatesÚcanÚaÚixÚbr?   s                       r@   Ú_choose_factorrd   (   s°  € ô �'˜!‘*œe×$Ñ$Ù!(Ó)¢˜A�Q”4¡ˆÐ)Ü
ˆ7ƒ|�qÓØ�q‰zÐà€EØ€FÜ$ S¨)×4Ñ4ˆc�kŠk¸"€GØ
Œ-ñ 4;Ó;²7¨a�i‰i‹k×"Ñ" A 5Ö)±7ˆÐ;Ø�;�;Ù%'Ó(¢R —#‘#�d–)¡RˆBÐ(ô œ˜u›¬¨W«À$ÔGˆAÜ˜Gž‘�Ø�q“	ñ (ô
 % Rœ=ô*Ú(‘C�Aô ˜qŸv™v f›~×/Ñ/°Ó6Ó7¸Ó;Ù(ð ñ *ô
 Ñ8©ZÓ8×8Ñ8Ùô
 ˜Ó$ˆCØ! " 1˜g‰O‰GˆQ�‘V�a˜Ø�1�u‘9�}Ø˜r‘{Ò"ñ' Hð* 	�‰
ˆð; Ž-ô> ÐTÐWXÑXÓ
YÐYùòM *ùò <ùâ(ùó*s   �F+Á.)F0Â.F5Ä7F:c                 óN   • [        S [        R                  " U 5       5       5      $ )Nc              3   ó<  #   • U  H’  n[         R                  " U5        Ht  nUR                  =(       d\    UR                  =(       aI    UR                  R                  =(       a,    S UR
                  -  R                  =(       a    UR                  v •  Mv     M”     g7f)rC   N)r	   Ú	make_argsÚis_RationalÚis_PowÚbaser   Ú
is_IntegerÚis_extended_real)r=   ÚtrZ   s      r@   rA   Ú _is_sum_surds.<locals>.<genexpr>Y   s|   é € ð =â!ˆA¬3¯=ª=¸×+; að �}‰}÷ K §¡÷ !KØ	�‰×Ñ÷!KØ ! !§%¡%¡×3Ñ3÷!KØ89×8JÑ8JôKá+;ñKâ!ùs   ‚BB)Úallr   rg   )Úps    r@   Ú_is_sum_surdsrq   X   s%   € Üñ =ä—’˜qÔ!ó=ó =ð =ó    c                 óV  • S n/ nU R                    GH
  nUR                  (       d¼  U" U5      (       a&  UR                  [        R                  US-  45        MH  UR
                  (       a#  UR                  U[        R                  45        M|  UR                  (       a>  UR                  R                  (       a#  UR                  U[        R                  45        MË  [        e[        UR                   USS9u  pEUR                  [        U6 [        U6 S-  45        GM     UR                  S S9  US   S   [        R                  L a  U $ U VVs/ s H  u  p6UPM	     nnn[        [        U5      5       H  nXx   S:w  d  M    O   S	S
KJn	  U	" UWS 6 u  p«n/ n/ nU HT  u  p6Xk;   a&  UR                  X6[        R"                  -  -  5        M0  UR                  X6[        R"                  -  -  5        MV     [%        U6 n[%        U6 n['        US-  5      ['        US-  5      -
  n U $ s  snnf )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                 ó`   • U R                   =(       a    U R                  [        R                  L $ r<   )ri   r   r   ÚHalf)Úexprs    r@   Úis_sqrtÚ_separate_sq.<locals>.is_sqrtx   s   € Ø�{‰{×1˜tŸx™x¬1¯6©6Ð1Ð1rr   rC   T)Úbinaryc                 ó   • U S   $ )Nr6   © )Úzs    r@   Ú<lambda>Ú_separate_sq.<locals>.<lambda>‰   s   € ˜˜1šrr   )Úkeyéÿÿÿÿr6   r   )Ú
_split_gcdN)ÚargsÚis_MulÚappendr   ÚOneÚis_Atomri   r   Ú
is_integerrS   r2   r	   ÚsortrL   rF   Úsympy.simplify.radsimpr�   ru   r   r   )rp   rw   ra   ÚyÚTÚFr|   Úsurdsr>   r�   ÚgÚb1Úb2Úa1Úa2Úp1Úp2s                    r@   Ú_separate_sqr•   ^   s³  € ò42ð 	€AØ�V�VˆØ�x�xÙ�q�z‰zØ—‘œ!Ÿ%™%  A¡˜Ö'Ø——Ø—‘˜!œQŸU™U˜Ö$Ø——˜aŸe™e×.×.Ø—‘˜!œQŸU™U˜Ö$ä)Ð)ä˜Ÿ™ °Ñ5‰DˆAØ�H‰H”c˜1�gœs A˜w¨™zÐ*×+ñ ð ‡F�F‰~€FÑØˆ�uˆQ�x”1—5‘5ÒàˆÙÔš1‘4�1‹Q™1€EÑÜ”3�u“:ÖˆØ‰8�q�=Ùñ õ 2Ù˜E ! "˜IÐ&�I€Aˆ2Ø	€BØ	€BÛ‰ˆØ‹7Ø�I‰I�aœ1Ÿ6™6™	‘kÖ"à�I‰I�aœ1Ÿ6™6™	‘kÖ"ñ	 ô
 
ˆbˆ€BÜ	ˆbˆ€BÜ��Q‘‹œ( 2 q¡5›/Ñ)€AØ€Hùó! s   ÅH%c                 óÎ  • [        U 5      n [        U5      nUR                  (       a  US:”  a  [        U 5      (       d  gU [        SU5      -  nX-  n  [	        U 5      nX@L a  UR                  X"U-  05      n OUn M)  US:X  aI  [        U 5      nU R                  X$R                  U5      -  5      S:  a  U * n U R                  5       S   n U $ [        U 5      S   n[        XRU5      nU$ )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   Nr6   )r   rk   rq   r   r•   rP   r    Úcoeffr&   Ú	primitiver#   rd   )rp   rK   rU   Úpnr“   rT   Úresults          r@   Ú_minimal_polynomial_sqr›   Ÿ   sã   € ô. 	�‹
€AÜ�‹
€AØ�<�<˜q 1›u¬M¸!×,<Ñ,<ØØ	
ŒH�Q˜‹NÑ	€Bà�F€AØ
Ü˜!‹_ˆØŠ7Ø—‘˜˜a™4˜Ó!ˆAØàˆAñ ð 	ˆAƒvÜ�!‹WˆØ�7‰7�1—i‘i “l‘?Ó# aÓ'Ø�ˆAØ�K‰K‹M˜!ÑˆØˆô ˜!‹n˜QÑ€Gä˜G¨Ó+€FØ€Mrr   Nc                 ó>  • [        [        U5      5      nUc  [        XU5      nUc  [        X'U5      nOUR                  X705      nU [        L a|  U[
        :X  a;  [        S[
        5      u  p‰U" [        U5      S   5      n
U" [        U5      S   5      nOX[        XSU-
  4X75      u  u  p«nU
R                  U5      nUR                  5       nO!U [        L a  [        XSU5      nO[        S5      eU [        L d
  U[
        :w  a  [        WXgU/S9nO&[        W
W5      n[!        UR#                  5       U5      n[%        XS5      n[%        Xg5      nU [        L a  US:X  d  US:X  a  U$ ['        XÓUS9nUR)                  5       u  nn[+        UX0" X5      U5      nUR                  5       $ )ap  
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".

ÚXr   zoption not available©Úgensr6   ©Údomain)r   ÚstrÚ_minpoly_composerP   r   r   r-   r*   r(   ÚcomposerH   r	   Ú_mulyrS   r%   r,   r+   Úas_expr_dictr&   r    r#   rd   )ÚopÚex1Úex2rU   rW   Úmp1Úmp2rŠ   ÚRr�   r“   r”   r?   ÚrÚmp1aÚdeg1Údeg2rT   Úress                      r@   Ú_minpoly_op_algebraic_elementr²   Õ   sy  € ôH 	Œc�!‹f‹€AØ
�{Ü˜s sÓ+ˆØ
�{Ü˜s sÓ+‰à�h‰h˜�vÓˆà	ŒS‚yà”"‹9Ü˜œR“=‰DˆAÙ”> #Ó& qÑ)Ó*ˆBÙ”> #Ó& qÑ)Ó*‰Bä1°3¸A¹°,ÀÓE‰K‰HˆR�aØ—
‘
˜2“ˆAØ—9‘9“;‰Dà	ŒsŠÜ�S˜QÓ‰ä!Ð"8Ó9Ð9à	ŒS‚y�Cœ2“IÜ�d˜C¨! fÑ-‰ä˜2˜rÓ"ˆÜ˜1Ÿ>™>Ó+¨QÓ/ˆä�#‹>€DÜ�#‹>€DØ	ŒS‚y�T˜Q“Y $¨!£)ð ˆäˆQ˜#Ñ€AØ—‘“�J€A€wÜ
˜ ! R¨£\°3Ó
7€CØ�;‰;‹=Ðrr   c                 óª   • [        X5      S   n[        U5      nUR                  5        VVs/ s H  u  u  pEXQX4-
  -  -  PM     nnn[        U6 $ s  snnf )z8
Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
r   ©r'   r&   Útermsr   )rp   rU   r“   rK   r>   Úcra   s          r@   Ú_invertxr·   $  sP   € ô 
˜Ó	˜aÑ	 €Bäˆr‹
€AØ')§x¡x¤zÔ2¢z™G™D˜Qˆ�‘‰ZŒ¡z€AÑ2Ü�ˆ7€Nùó 	3s   ­Ac                 ó¶   • [        X5      S   n[        U5      nUR                  5        VVs/ s H  u  u  pVXaU-  -  X$U-
  -  -  PM     nnn[        U6 $ s  snnf )z0
Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
r   r´   )rp   rU   rŠ   r“   rK   r>   r¶   ra   s           r@   r¥   r¥   /  sY   € ô 
˜Ó	˜aÑ	 €Bäˆr‹
€AØ.0¯h©h¬jÔ9ªj¡7¡4 Aˆ�‰T‰�A˜A™‘JÔ	©j€AÑ9Ü�ˆ7€Nùó 	:s   ­Ac                 óì  • [        U5      nU(       d  [        XU5      nUR                  (       d  [        SU -  5      eUS:  a.  XB:X  a  [	        SU -  5      e[        XB5      nUS:X  a  U$ U* nSU -  n [        [        U5      5      nUR                  X%05      nUR                  5       u  pg[        [        XBU-  XV-  -
  U/S9X#S9nUR                  5       u  pš[        X¢X-  U5      nUR                  5       $ )a8  
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 zeror€   r6   rž   r    )r   r£   Úis_rationalr   ÚZeroDivisionErrorr·   r   r¢   rP   Úas_numer_denomr    r%   r#   rd   rH   )ÚexÚpwrU   rW   ÚmprŠ   rK   Údr±   r?   rT   s              r@   Ú_minpoly_powrÂ   :  sê   € ô< 
�‹€BÞÜ˜b SÓ)ˆØ�>�>ÜÐHÈ2ÑMÓNÐNØ	ˆAƒvØ‹7Ü# L°2Ñ$5Ó6Ð6Ü�b‹_ˆØ�‹8ØˆIØˆSˆØˆr‰TˆäŒc�!‹f‹€AØ	�‰�!�‹€BØ×ÑÓ�D€AÜ
Œy˜ ™T A¡D™[°¨sÑ3°QÑ
C€CØ—‘Ó"�J€AÜ
˜ R¡V¨SÓ
1€CØ�;‰;‹=Ðrr   c           
      óŒ   • [        [        US   US   X5      nUS   US   -   nUSS  H  n[        [        XEXUS9nXE-   nM     U$ )z&
returns ``minpoly(Add(*a), dom, x)``
r   r6   rC   N©rª   )r²   r   ©rU   rW   ra   rÀ   rp   Úpxs         r@   Ú_minpoly_addrÇ   o  ó[   € ô 
'¤s¨A¨a©D°!°A±$¸Ó	?€BØ	ˆ!‰ˆq�‰t‰€AØ��‹eˆÜ*¬3°°qÀ2ÑFˆØ‰FŠñ ð €Irr   c           
      óŒ   • [        [        US   US   X5      nUS   US   -  nUSS  H  n[        [        XEXUS9nXE-  nM     U$ )z&
returns ``minpoly(Mul(*a), dom, x)``
r   r6   rC   NrÄ   )r²   r	   rÅ   s         r@   Ú_minpoly_mulrÊ   {  rÈ   rr   c                 ó  • U R                   S   R                  5       u  p#U[        L GaL  UR                  (       Ga:  UR                  n[        U5      nUR                  (       a>  [        U[        5      n[        [        U5       Vs/ s H  oaXF-
  S-
  -  X6   -  PM     sn6 $ UR                  S:X  a#  US:X  a  SUS-  -  SUS-  -  -
  SUS	-  -  -   S
-
  $ US	-  S:X  aZ  [        U[        5      n[        US-   5       Vs/ s H  oaXF-
  -  X6   -  PM     nn[        U6 n[        U5      u  p‰[        X‘U 5      n
U
$ S[        S	U-  [        -  5      -
  S	-  [        R                   -  n[#        X±[$        5      n
U
$ ['        SU -  5      es  snf s  snf )zi
Returns the minimal polynomial of ``sin(ex)``
see https://mathworld.wolfram.com/TrigonometryAngles.html
r   r6   é	   é@   é   é`   é   é$   rC   é   rº   )r‚   Úas_coeff_Mulr   r»   Úqr   Úis_primer   r   r   rL   rp   r#   rd   r   r   ru   r£   r   r   )r¾   rU   r¶   ra   rK   rÔ   r>   r­   r?   rT   r±   rv   s               r@   Ú_minpoly_sinrÖ   ‡  ss  € ð
 �7‰7�1‰:×"Ñ"Ó$�D€AØŒBƒwØ�=�=ˆ=Ø—‘ˆAÜ˜“
ˆAØ�z�zô # 1¤bÓ)�Ü¼%À¼(ÓCº(°Q ¡¨¡™^¨A©DÔ0¹(ÑCÐDÐDØ�s‰s�a‹xØ˜“6Ø˜a ™d™7 R¨¨1©¡WÑ,¨r°!°Q±$©wÑ6¸Ñ:Ð:à�1‰u˜‹zô # 1¤bÓ)�Ü.3°A¸±E¬lÓ;ªl¨˜™‘Z ¡”_©l�Ð;Ü˜�G�Ü(¨›^‘
�Ü$ W°Ó4�Ø�
àœ˜Q˜q™S¤™V›‘_ aÑ'¬!¯&©&Ñ0ˆDÜ" 4¬BÓ/ˆCØˆJä
ÐDÀrÑIÓ
JÐJùò) Dùò <s   ÂFÃ>F	c           	      ó,  • U R                   S   R                  5       u  p#U[        L GaY  UR                  (       GaG  UR                  S:X  aL  UR
                  S:X  a  SUS-  -  SUS-  -  -
  SU-  -
  S-   $ UR
                  S:X  a  SUS-  -  S	U-  -
  S-
  $ OlUR                  S:X  a\  [        UR
                  5      nUR                  (       a6  [        X5      n[        UR                  U[        SU-
  S-  5      05      5      $ [        UR
                  5      n[        U[        5      n[        US-   5       Vs/ s H  oqXg-
  -  X7   -  PM     nn[!        U6 S
UR                  -  -
  n[#        U5      u  pš[%        X¡U 5      nU$ ['        SU -  5      es  snf )zi
Returns the minimal polynomial of ``cos(ex)``
see https://mathworld.wolfram.com/TrigonometryAngles.html
r   r6   é   é   rÒ   rÐ   rC   rÌ   rÎ   r€   rº   )r‚   rÓ   r   r»   rp   rÔ   r   rÕ   rÖ   r   rP   r   Úintr   r   rL   r   r#   rd   r   )r¾   rU   r¶   ra   rÔ   r^   rK   r>   r­   r?   rT   r±   s               r@   Ú_minpoly_cosrÛ   ­  sl  € ð
 �7‰7�1‰:×"Ñ"Ó$�D€AØŒBƒwØ�=�=ˆ=Ø�s‰s�a‹xØ—3‘3˜!“8Ø˜Q ™T™6 A a¨¡d¡F™?¨Q¨q©SÑ0°1Ñ4Ð4Ø—3‘3˜!“8Ø˜Q ™T™6 A a¡C™<¨!Ñ+Ð+ð à—‘˜“Ü˜AŸC™C“L�Ø—:—:Ü$ RÓ+�AÜ# A§F¡F¨A¬d°A¸±E¸1±9«oÐ+>Ó$?Ó@Ð@ô �A—C‘C“ˆAÜ˜q¤"Ó%ˆAÜ*/°°A±¬,Ó7ª, Q�Q‘U‘˜A™D”©,ˆAÐ7Ü�Q�˜2 §¡™)Ñ#ˆAÜ$ Q›‰JˆAÜ  ¨RÓ0ˆCØˆJä
ÐDÀrÑIÓ
JÐJùò 8s   Ä9Fc                 óî  • U R                   S   R                  5       u  p#U[        L aÀ  UR                  (       a¯  US-  n[	        UR
                  5      nUR                  S-  S:X  a  UOSn/ n[        UR                  S-   S-  US-   S5       H5  nUR                  X1U-  -  5        X4U-
  S-
  -  XF-
  -  * US-   US-   -  -  nM7     [        U6 n[        U5      u  p‰[        X‘U 5      n
U
$ [        SU -  5      e)z_
Returns the minimal polynomial of ``tan(ex)``
see https://github.com/sympy/sympy/issues/21430
r   rC   r6   rº   )r‚   rÓ   r   r»   rÚ   rÔ   rp   rL   r„   r   r#   rd   r   )r¾   rU   r¶   ra   rK   rµ   r9   r­   r?   rT   r±   s              r@   Ú_minpoly_tanrÝ   Ì  sð   € ð
 �7‰7�1‰:×"Ñ"Ó$�D€AØŒB‚wØ�=�=Ø�A‘ˆAÜ�A—C‘C“ˆAØ—S‘S˜1‘W “\‘ qˆAØˆEÜ˜AŸC™C ™E 1™9 a¨¡c¨1Ö-�Ø—‘˜Q !™t™VÔ$Ø˜1™˜Q™‘i ¡‘oÐ&¨A¨a©C°!°A±#©;Ñ7’ñ .ô �U�ˆAÜ$ Q›‰JˆAÜ  ¨RÓ0ˆCØˆJä
ÐDÀrÑIÓ
JÐJrr   c                 óæ  • U R                   S   R                  5       u  p#U[        [        -  :X  Ga.  UR                  (       Ga  [        UR                  5      nUR                  S:X  d  UR                  S:X  a¤  US:X  a  US-  U-
  S-   $ US:X  a  US-  S-   $ US:X  a  US-  US-  -
  S-   $ US:X  a  US-  S-   $ US	:X  a  US-  US-  -
  S-   $ US
:X  a  US-  US-  -
  US-  -   US-  -
  S-   $ UR                  (       a  Sn[        U5       H  nXQ* U-  -  nM     U$ [        SU-  5       Vs/ s H  n[        Xa5      PM     nn[        XqU 5      nU$ [        SU -  5      e[        SU -  5      es  snf )z/
Returns the minimal polynomial of ``exp(ex)``
r   r6   r€   rÒ   rC   rÐ   rÎ   rÙ   rÌ   r7   rº   )r‚   rÓ   r
   r   r»   r   rÔ   rp   rÕ   rL   r   r/   rd   r   )	r¾   rU   r¶   ra   rÔ   r^   r>   rT   rÀ   s	            r@   Ú_minpoly_exprß   ä  s…  € ð �7‰7�1‰:×"Ñ"Ó$�D€AØŒAŒb‰D„yØ�=�=ˆ=Ü˜Ÿ™“ˆAØ�s‰s�a‹x˜1Ÿ3™3 "›9Ø˜“6Ø˜a™4 !™8 a™<Ð'Ø˜“6Ø˜a™4 !™8�OØ˜“6Ø˜a™4 ! Q¡$™;¨™?Ð*Ø˜“6Ø˜a™4 !™8�OØ˜“6Ø˜a™4 ! Q¡$™;¨™?Ð*Ø˜“7Ø˜a™4 ! Q¡$™;¨¨A©Ñ-°°1±Ñ4°qÑ8Ð8Ø—:—:Ø�AÜ" 1žX˜Ø˜b 1™W™šñ &à�Hô 7?¸qÀ¹s´mÓD²m°” qÖ,±mˆGÐDÜ ¨BÓ/ˆBØˆIäÐLÈrÑQÓRÐRÜ
ÐDÀrÑIÓ
JÐJùò Es   Ä-E.c                 ó¤   • U R                   nUR                  U R                  R                  S   U05      n[	        X!5      u  p4[        XAU 5      nU$ )z9
Returns the minimal polynomial of a ``CRootOf`` object.
r   )rv   rP   ÚpolyrŸ   r#   rd   )r¾   rU   rp   r?   rT   rš   s         r@   Ú_minpoly_rootofrâ     sI   € ð 	�‰€AØ	�‰�—‘—‘˜Q‘ Ð"Ó#€AÜ˜QÓ"�J€AÜ˜G¨Ó+€FØ€Mrr   c           
      óB	  • U R                   (       a  U R                  U-  U R                  -
  $ U [        L a2  [	        US-  S-   XS9u  p4[        U5      S:X  a  US-  S-   $ U[        -
  $ U [        R                  L aI  [	        US-  U-
  S-
  XS9u  p4[        U5      S:X  a  US-  U-
  S-
  $ [        XAS[        S5      -   S-  US9$ U [        R                  L a€  [	        US-  US-  -
  U-
  S-
  XS9u  p4[        U5      S:X  a  US-  US-  -
  U-
  S-
  $ S[        SS[        S5      -  -
  5      -   [        SS[        S5      -  -   5      -   S-  n[        XAXRS9$ [        US	5      (       a  XR                  ;   a  X-
  $ UR                  (       aB  [        U 5      (       a2  U nX-  n  [!        U 5      nXpL a  [        [	        U 5      S   X5      $ Un M+  U R"                  (       a  [%        X/U R&                  Q76 nU$ U R(                  (       Ga¤  [+        U 5      R,                  n	[/        U	R1                  5       S
 5      n
U
S   (       GaP  U[2        :X  GaE  [5        U
S   U
S   -    VV s/ s H	  u  p°X°-  PM     sn n6 n[7        U
S   5      nUR9                  5        Vs/ s H  oÝR                  PM     nn[;        [<        US5      n[        R>                  nURA                  U[        RB                  5      nUR1                  5        VVs/ s H%  u  nnUUR                  U-  UR                  -  -  PM'     nnn[5        U6 n[E        Xq5      nUR                  X-  -  UR                  UUU-  -  -  -
  nUU-  U[G        SU5      -  -  n[I        [4        UUXUUS9nU$ [K        X/U R&                  Q76 n U$ U RL                  (       a#  [O        U RP                  U RR                  X5      nU$ U RT                  [V        L a  [Y        X5      nU$ U RT                  [Z        L a  []        X5      nU$ U RT                  [^        L a  [a        X5      nU$ U RT                  [R        L a  [c        X5      nU$ U RT                  [d        L a  [g        X5      nU$ [i        SU -  5      es  sn nf s  snf s  snnf )au  
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

rC   r6   r    r4   )rW   rÒ   é   é!   r8   c                 óL   • U S   R                   =(       a    U S   R                   $ )Nr   r6   )rh   )Úitxs    r@   r}   Ú"_minpoly_compose.<locals>.<lambda>J  s    € ¨¨A©×(:Ñ(:×(Q¸sÀ1¹v×?QÑ?QÐ(Qrr   TFN)rª   r«   rº   )5rh   rÔ   rp   r
   r#   rF   r   ÚGoldenRatiord   r   ÚTribonacciConstantr   rG   r8   Úis_QQrq   r•   Úis_AddrÇ   r‚   rƒ   r   rT   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¾   rU   rW   r?   rT   ÚfacrV   r¨   r±   rZ   r­   ÚbxÚr1rŠ   ÚdensÚlcmdensÚneg1Úexpn1rj   Únumsr©   rª   r«   s                          r@   r£   r£     sM  € ð  
‡~‡~Ø�t‰t�A‰v˜Ÿ™‰}ÐØ	ŒQ‚wÜ   A¡¨¡¨1Ñ9‰
ˆÜ˜w›<¨1Ó,ˆq�!‰t�a‰xÐ7°!´a±%Ð7à	ŒQ�]‰]ÒÜ   A¡¨¡¨A¡¨qÑ=‰
ˆÜˆw‹<˜1ÓØ�a‘4˜!‘8˜a‘<Ðä! '¨q´4¸³7©{¸A©oÀ3ÑGÐGà	ŒQ×!Ñ!Ò!Ü   A¡¨¨1©¡¨q¡°1Ñ!4°aÑD‰
ˆÜˆw‹<˜1ÓØ�a‘4˜!˜Q™$‘; ‘? QÑ&Ð&à”t˜B ¤4¨£8¡™OÓ,Ñ,¬t°B¸¼4À»8¹±OÓ/DÑDÈÑIˆCÜ! '¨cÑ;Ð;äˆs�I×Ñ 2¯©Ó#4Ø‰vˆà
‡y‡y”] 2×&Ñ&àˆØ
‰ˆØÜ˜rÓ"ˆCØŠyÜ%¤k°"£o°aÑ&8¸!Ó?Ð?à�ñ ð 
‡y‡yÜ˜1Ð, B§G¡GÒ,ˆðL €JðK 
��ˆÜ�B‹K×ÑˆÜ�—‘“ÑQÓRˆØˆT�7ˆ7�sœb”yÜ¨Q¨u©X¸¸$¹Ò-?Ô@Ò-?¡6 2˜œÑ-?Ò@ÐAˆCÜ�a˜‘g“ˆBØ!#§¡¤Ó-¢˜A—C”C¡ˆDÐ-ÜœS $¨Ó*ˆGÜ—=‘=ˆDØ—F‘F˜4¤§¡Ó(ˆEØ>@¿h¹h¼jÔIºj±7°4¸�D˜1Ÿ3™3˜w™;¨!¯#©#Ñ-Ô.¹jˆDÑIÜ�t�*ˆCÜ$ SÓ,ˆCð —%‘%˜™
Ñ" S§U¡U¨4°%¸±-Ñ+@Ñ%@Ñ@ˆCØ˜‘+ ¤X¨a°Ó%9Ñ 9Ñ9ˆCÜ/´°S¸#¸qÈ3ÐTWÑXˆCð" €Jô ˜qÐ0¨¯©Ò0‰Cð €Jð 
��Ü˜2Ÿ7™7 B§F¡F¨AÓ3ˆð €Jð 
�‰œÒ	Ü˜2Ó!ˆð €Jð 
�‰œÒ	Ü˜2Ó!ˆð €Jð 
�‰œÒ	Ü˜2Ó!ˆð €Jð 
�‰œÒ	Ü˜2Ó!ˆð
 €Jð	 
�‰œÒ	 Ü˜bÓ$ˆð €Jô ÐHÈ2ÑMÓNÐNùóA Aùâ-ùó Js   É#R
ÊRÌ,Rc                 óZ  • [        U 5      n U R                  (       a
  [        U SS9n [        U 5       H  nUR                  (       d  M  Sn  O   Ub  [        U5      [
        paO[        S5      [        paU(       d;  U R                  (       a$  [        [        [        U R                  5      5      nO[        n[        US5      (       a"  XR                  ;   a  [        SU< SU< 35      eU(       ax  [        XU5      nUR!                  5       S   nUR#                  U[%        Xq5      -  5      nUR&                  (       a  [)        U* 5      nU(       a  U" XqSS	9$ UR+                  U5      $ UR,                  (       d  [/        S
5      e[1        XU5      nU(       a  U" XqSS	9$ UR+                  U5      $ )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)Ú	recursiveFrU   r8   zthe variable z$ is an element of the ground domain r6   )Úfieldz!groebner method only works for QQ)r   rJ   r   r   Úis_AlgebraicNumberr    r   r!   Úfree_symbolsr   r   ÚlistrG   r8   r   r£   r˜   r—   r&   Úis_negativer   Úcollectrë   rS   Ú_minpoly_groebner)	r¾   rU   r¤   Úpolysr¡   rv   Úclsrš   r¶   s	            r@   ró   ró   p  sZ  € ôn 
�‹€BØ	‡|‡|ä�b DÑ)ˆÜ" 2Ö&ˆØ×"×"Ñ"ØˆGÙñ 'ð
 	�}Ü˜“œT‰3ä�s“œXˆ3æØ�?�?Ü"¤2¤t¨B¯O©OÓ'<Ó=‰FäˆFÜˆv�y×!Ñ! a¯>©>Ó&9ÝÛ-.²ð8ó 9ð 	9ö Ü! "¨Ó0ˆØ×!Ñ!Ó# AÑ&ˆØ�L‰L˜œF 6Ó-Ñ-Ó.ˆØ�=�=Ü  Ó(ˆFÞ-2‰s�6 DÑ)ÐI¸¿¹ÀqÓ8IÐIà�<�<Ü!Ð"EÓFÐFä˜r cÓ*€FÞ).‰3ˆv Ñ%ÐE°F·N±NÀ1Ó4EÐErr   c                 óØ  ^^^^^^^• [        S[        S9m0 0 smmSUUU4S jjmUUUUUU4S jmS nSn[        U 5      n U R                  (       a  U R	                  5       R                  T5      $ U R                  (       a  U R                  T-  U R                  -
  nGO
U" U 5      nU(       a  U S-  n SnU R                  (       aE  S	U R                  -  R                  (       a'  S	U R                  -  n[        U R                  UT5      nO+[        U 5      (       a  [        U [        R                   T5      nUb  UnUck  T" U 5      nTU-
  /[#        TR%                  5       5      -   n	['        U	[#        TR%                  5       5      T/-   S
S9n
[)        U
S   5      u  p¼[+        UTU 5      nU(       a:  [-        WT5      nUR/                  T[1        UT5      -  5      S:  a  [3        U* 5      nW$ )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

ra   )r  Nc                 óp   >• [        T5      nUTU '   Ub  X1-  U-   TU '   U$ UR                  " U5      TU '   U$ r<   )ÚnextrH   )r¾   r   rj   ra   Ú	generatorÚmappingr8   s       €€€r@   Úupdate_mappingÚ)_minpoly_groebner.<locals>.update_mappingß  sI   ø€ Ü�‹OˆØˆ�‰àÑØ™& 4™-ˆG�B‰Kð ˆð Ÿ+š+ a›.ˆG�B‰Kàˆrr   c                 ó0  >• U R                   (       a=  U [        R                  L a  U T
;  a
  T" U SS5      $ TU    $ U R                  (       a  U $ GO0U R                  (       a)  [        U R                   Vs/ s H  nT" U5      PM     sn6 $ U R                  (       a)  [        U R                   Vs/ s H  nT" U5      PM     sn6 $ U R                  (       Gax  U R                  R                  (       Ga[  U R                  S:  a‚  [        U R                  TT	5      n[        TU5      R                  5       nUR                  TU R                  5      R!                  5       nU R                  S:X  a  T" U5      $ X@R                  * -  n U R                  R"                  (       dQ  U R                  U R                  R$                  -  R!                  5       ['        SU R                  R(                  5      peOU R                  U R                  peT" U5      nXV-  nUT
;  a/  UR"                  (       a  UR!                  5       $ T" USU-  U* 5      $ TU   $ O2U R*                  (       a!  U T
;  a  T" X R-                  5       5      $ TU    $ [/        SU -  5      es  snf s  snf )a3  
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.

rC   r6   r   r€   z*%s does not seem to be an algebraic number)r†   r   ÚImaginaryUnitrh   rì   r   r‚   rƒ   r	   ri   r   r  rj   r"   rH   rP   Úexpandrk   rp   r   rÔ   r   Úminpoly_of_elementr   )r¾   rŽ   Úminpoly_baseÚinverseÚbase_invrj   r   rv   Úbottom_up_scanr  r  r8   r  rU   s           €€€€€€r@   r  Ú)_minpoly_groebner.<locals>.bottom_up_scanê  s  ø€ ð8 �:�:Ø”Q—_‘_Ò$Ø˜WÓ$Ù)¨"¨a°Ó3Ð3à" 2™;Ð&Ø——Ø�	ñ  à�Y�YÜ°R·W²WÓ>²W°™.¨Ö+±WÑ>Ð?Ð?Ø�Y�YÜ°R·W²WÓ>²W°™.¨Ö+±WÑ>Ð?Ð?Ø�Y�YˆYØ�v‰v×!×!Ð!Ø—6‘6˜A“:Ü#4°R·W±W¸aÀÓ#E�LÜ$ Q¨Ó5×=Ñ=Ó?�GØ&Ÿ|™|¨A¨r¯w©wÓ7×>Ñ>Ó@�Hà—v‘v “|Ù-¨hÓ7Ð7à%¯©¨Ñ0˜Ø—v‘v×(×(àŸ™ §¡§¡Ñ)¯6©6«8´X¸aÀÇÁÇÁÓ5Jñ ð !#§¡¨¯©˜#Ù% dÓ+�Ø‘y�à˜wÓ&Ø—~—~Ø#Ÿ{™{›}Ð,á-¨d°A¸±G¸d¸UÓCÐCà" 4™=Ð(ð1 "ð2 ×"×"Ø˜Ó Ù% b×*?Ñ*?Ó*AÓBÐBà˜r‘{Ð"äÐGÈ"ÑLÓMÐMùòG ?ùâ>s   Á4JÂ.Jc                 óÀ  • U R                   (       aJ  SU R                  -  R                  (       a,  U R                  S:  a  U R                  R                  (       a  gU R
                  (       ar  SnU R                   HX  nUR                  (       a    gUR                   (       d  M)  UR                  R                  (       d  MF  UR                  S:”  d  MX    g   U(       a  gg)zg
Returns True if it is more likely that the minimal polynomial
algorithm works better with the inverse
r6   r   TF)ri   r   r‡   rj   rì   rƒ   r‚   )r¾   Úhitrp   s      r@   Úsimpler_inverseÚ*_minpoly_groebner.<locals>.simpler_inverse4  s†   € ð
 �9�9Ø�"—&‘&‘×$×$¨¯©°!«Ø—7‘7—>—>ØØ�9�9ØˆCØ—W”W�Ø—8—8Ù Ø—8—8‘8Ø—v‘v—}—}‘}¨¯©°­Ù$ñ ö ØØrr   Fr€   r6   Úlex)Úorderr   r<   )r0   r   r   r   r  rH   rh   rÔ   rp   ri   r   rk   r›   rj   rq   r   r…   r  rï   r$   r#   rd   r·   r—   r&   r   )r¾   rU   r  r  Úinvertedrš   r±   rK   ÚbusrŒ   ÚGr?   rT   r  r  r  r8   r  s    ``          @@@@@r@   r  r  Í  sª  þ€ ô ! ¬%Ñ0€IØ˜2Ð€GˆW÷	ñ 	÷HNò HNòTð, €HÜ	˜BÓ	€BØ	××Ø×$Ñ$Ó&×.Ñ.¨qÓ1Ð1Ø	��Ø—‘�a‘˜"Ÿ$™$‘Šá" 2Ó&ˆÞØ�R‘ˆBØˆØ�9�9˜!˜BŸF™F™(×.×.Ø�"—&‘&‘ˆAÜ(¨¯©°!°QÓ7‰Cä˜2×ÑÜ(¨¬Q¯U©U°AÓ6ˆCà‰?ØˆFà‰;Ù  Ó$ˆCØ�S‘�	œD §¡Ó!1Ó2Ñ2ˆAÜ˜œD §¡Ó!1Ó2°a°SÑ8ÀÑFˆAä$ Q r¡UÓ+‰JˆAä# G¨Q°Ó3ˆFÞÜ˜& !Ó$ˆØ�<‰<˜œ6 &¨!Ó,Ñ,Ó-°Ó1Ü  Ó(ˆFà€Mrr   c                 ó   • [        XX#US9$ )z6This is a synonym for :py:func:`~.minimal_polynomial`.)rU   r¤   r  r¡   )ró   )r¾   rU   r¤   r  r¡   s        r@   Úminpolyr"  o  s   € ô ˜b¨wÈFÑSÐSrr   )NNr<   )NTFN)]Ú__doc__Ú	functoolsr   Úsympy.core.addr   Úsympy.core.exprtoolsr   Úsympy.core.functionr   r   r   Úsympy.core.mulr	   Úsympy.core.numbersr
   r   r   r   Ú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+   Úsympy.polys.ring_seriesr,   Úsympy.polys.ringsr-   Úsympy.polys.rootoftoolsr.   Úsympy.polys.specialpolysr/   Úsympy.utilitiesr0   r1   r2   rd   rq   r•   r›   r²   r·   r¥   rÂ   rÇ   rÊ   rÖ   rÛ   rÝ   rß   râ   r£   ró   r  r"  r{   rr   r@   Ú<module>r=     s  ðÙ 0å å Ý (ß HÑ HÝ ß :Ó :Ý "Ý #Ý &Ý 3Ý 6ß ?ß BÑ BÝ *Ý -ç 5Ñ 5Ý 1÷÷÷ ÷ ÷ AÝ 2Ý "Ý +Ý 4÷ñ ð
 ')¨s¸!ô -Zò`=ò?òB4ôlLò^òô2òj	ò	ò#KòLKò>Kò0!KòHòZðz óYFó ðYFòx_ðD óTó ñTrr   