
    sgDl                     &   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ZJd ZKd ZLd  ZMd1d"ZNd# ZOd$ ZPd2d%ZQd& ZRd' ZSd( ZTd) ZUd* ZVd+ ZWd, ZXd- ZYeHd3d.       ZZd/ Z[eHd3d0       Z\y!)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           
      F   t        | d   t              r| D cg c]  }|d   	 } }t        |       dk(  r| d   S d}i }t        |d      r|j                  ng }	||k  r#| D cg c]#  }|j                         j                  ||i      % }
}|j                  r|
D cg c]  }|j                  |       }
}t        t        |      t        |	      d      D ]  }t        |	|      D ]
  \  }}|||<    t        |
      D cg c]0  \  }}t        |j                  |      j                  |            |f2 }}}t        d |D              rut!        |      }|dd	 \  \  }}\  }}||d
z  kD  s| |   c S  |d	z  }||k  r#t#        d|z        c c}w c c}w c c}w c c}}w )ze
    Return a factor having root ``v``
    It is assumed that one of the factors has root ``v``.
    r      
   symbolsT)k
repetitionc              3   2   K   | ]  \  }}|t         v   y wN)r   ).0i_s      S/var/www/html/venv/lib/python3.12/site-packages/sympy/polys/numberfields/minpoly.py	<genexpr>z!_choose_factor.<locals>.<genexpr>H   s     8TQ1=8s   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   ferJ   sr>   
candidatescanaixbr?   s                       r@   _choose_factorrc   (   s    '!*e$!()A1Q4))
7|qqzEF$S)4ckk"G
4- 4;;aaiik""Aa5);;;;%'(!##d)(B( uW$G 	#AGQ 1q	
 %R=*Aa qvvf~//67; *J *
 8Z88
 $C!"1gOGQVa1u9}r{"'	#* 	
; 4-> TWXX
YYM * <(*s   F!(FF?5Fc                     | j                   r| j                  n| g}|D ]  }|dz  j                  r|j                  r y y)NrB   FT)is_Addargsis_Rationalis_extended_real)prf   ys      r@   _is_sum_surdsrk   X   sA    XX166A3D A""q'9'9     c                    d }g }| j                   D ]  }|j                  s ||      r%|j                  t        j                  |dz  f       <|j
                  r"|j                  |t        j                  f       j|j                  r8|j                  j                  r"|j                  |t        j                  f       t        t        |j                   |d      \  }}|j                  t        | t        | dz  f        |j                  d        |d   d   t        j                  u r| S |D cg c]  \  }}|	 }}}t        t        |            D ]  }||   dk7  s n d	d
lm}	  |	|d  \  }
}}g }g }|D ]T  \  }}||v r&|j                  ||t        j"                  z  z         0|j                  ||t        j"                  z  z         V t%        | }t%        | }t'        |dz        t'        |dz        z
  } | S c c}}w )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                 V    | j                   xr | j                  t        j                  u S r<   )is_Powr   r   Half)exprs    r@   is_sqrtz_separate_sq.<locals>.is_sqrtz   s    {{1txx16611rl   rB   T)binaryc                     | d   S )Nr6    )zs    r@   <lambda>z_separate_sq.<locals>.<lambda>   s
    1 rl   )keyr6   r   )
_split_gcdN)rf   is_Mulappendr   Oneis_Atomro   r   
is_integerrR   r2   r	   sortrK   rE   sympy.simplify.radsimprz   rp   r   r   )ri   rr   r`   rj   TFrv   surdsr>   rz   gb1b2a1a2p1p2s                    r@   _separate_sqr   `   s   42 	AVV ,xxqz!%%A'!QUU$aee..!QUU$))5DAqHHc1gsAwz*+, FF~FuQx15541aQE3u: 8q= 2E!"I&IAr2	B	B #17IIa166	k"IIa166	k"	#
 
bB	bBQ(2q5/)AH! s   7Hc                    t        |       } t        |      }|j                  r|dkD  rt        |       sy| t        d|      z  }| |z  } 	 t	        |       }|| u r|j                  |||z  i      } n|} )|dk(  rIt        |       }| j                  ||j                  |      z        dk  r|  } | j                         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   Nr6   )r   
is_Integerrk   r   r   rO   r    coeffr&   	primitiver#   rc   )ri   rJ   rT   pnr   rS   results          r@   _minimal_polynomial_sqr      s    . 	
A
A<<q1uM!,<	
HQN	BFA
!_71a4!AA  	Av!W771biil?#a'AKKM! !nQGGQ+FMrl   Nc                 R   t        t        |            }|t        |||      }|t        |||      }n|j                  ||i      }| t        u r|t
        k(  r<t        dt
              \  }}	 |t        |      d         }
 |t        |      d         }n[t        |||z
  f||      \  \  }
}}|
j                  |      }|j                         }n!| t        u rt        |||      }nt        d      | t        u s	|t
        k7  rt        |||g      }n&t        
      }t!        |j#                         |      }t%        ||      }t%        ||      }| t        u r|dk(  s|dk(  r|S t'        |||      }|j)                         \  }}t+        || | ||      |      }|j                         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".

    Xr   zoption not availablegensr6   domain)r   str_minpoly_composerO   r   r   r-   r*   r(   composerG   r	   _mulyrR   r%   r,   r+   as_expr_dictr&   r    r#   rc   )opex1ex2rT   rV   mp1mp2rj   Rr   r   r   r?   rmp1adeg1deg2rS   ress                      r@   _minpoly_op_algebraic_elementr      s   H 	c!fA
{sAs+
{sAs+hh1v	Sy"9R=DAq>#&q)*B>#&q)*B13A,1EKHRa

2A99;D	sS!Q!"899	SyC2IdCq!f-2r"1>>+Q/#q>D#q>D	SyTQY$!) Q#AJAw
!RS\3
7C;;=rl   c                     t        | |      d   }t        |      }|j                         D cg c]  \  \  }}||||z
  z  z   }}}t        | S c c}}w )z@
    Returns ``expand_mul(x**degree(p, x)*p.subs(x, 1/x))``
    r   r'   r&   termsr   )ri   rT   r   rJ   r>   cr`   s          r@   _invertxr   &  sW     
1	a	 Br
A')xxz2GDQ!QQZ2A27N 	3s   Ac                     t        | |      d   }t        |      }|j                         D cg c]  \  \  }}|||z  z  |||z
  z  z   }}}t        | S c c}}w )z8
    Returns ``_mexpand(y**deg*p.subs({x:x / y}))``
    r   r   )ri   rT   rj   r   rJ   r>   r   r`   s           r@   r   r   1  s`     
1	a	 Br
A.0hhj974AQTAAJ	9A97N 	:s   Ac                    t        |      }|st        | ||      }|j                  st        d| z        |dk  r.||k(  rt	        d| z        t        ||      }|dk(  r|S | }d| z  } t        t        |            }|j                  ||i      }|j                         \  }}t        t        |||z  ||z  z
  |g      ||      }|j                         \  }	}
t        |
|| |z  |      }|j                         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 zerory   r6   r   r   )r   r   is_rationalr   ZeroDivisionErrorr   r   r   rO   as_numer_denomr    r%   r#   rc   rG   )expwrT   rV   mprj   rJ   dr   r?   rS   s              r@   _minpoly_powr   <  s    < 
Bb!S)>>H2MNN	Av7#L2$566b!_8ISrTc!fA	!QBDAq
yQTAqD[s3Qs
CC"JAw
!RVS
1C;;=rl   c           	          t        t        |d   |d   | |      }|d   |d   z   }|dd D ]  }t        t        ||| ||      }||z   } |S )z.
    returns ``minpoly(Add(*a), dom, x)``
    r   r6   rB   Nr   )r   r   rT   rV   r`   r   ri   pxs         r@   _minpoly_addr   q  h     
'sAaD!A$3	?B	!qtAe *32q#2FF Irl   c           	          t        t        |d   |d   | |      }|d   |d   z  }|dd D ]  }t        t        ||| ||      }||z  } |S )z.
    returns ``minpoly(Mul(*a), dom, x)``
    r   r6   rB   Nr   )r   r	   r   s         r@   _minpoly_mulr   }  r   rl   c                    | j                   d   j                         \  }}|t        u rB|j                  r5|j                  }t        |      }|j                  r>t        |t              }t        t        |      D cg c]  }|||z
  dz
  z  ||   z   c} S |j                  dk(  r"|dk(  rd|dz  z  d|dz  z  z
  d|d	z  z  z   d
z
  S |d	z  dk(  r\t        |t              }t        |dz         D cg c]  }|||z
  z  ||   z   }}t        | }t        |      \  }}	t        |	||       }
|
S dt        d	|z  t        z        z
  d	z  t        j                   z  }t#        ||t$              }
|
S t'        d| z        c c}w c c}w )zu
    Returns the minimal polynomial of ``sin(ex)``
    see https://mathworld.wolfram.com/TrigonometryAngles.html
    r   r6   	   @      `      $   rB      r   )rf   as_coeff_Mulr   r   qr   is_primer   r   r   rK   ri   r#   rc   r   r   rp   r   r   r   )r   rT   r   r`   rJ   r   r>   r   r?   rS   r   rq   s               r@   _minpoly_sinr     s   
 771:""$DAqBw==A
Azz #1b)%(CQQQ^AaD0CDDssax6ad7R1W,r!Q$w6::1uz #1b).3AEl;QQZ!_;;G(^
7$Wa4
QqSV_a'!&&0D"4B/CJ
DrI
JJ) D <s   <E:1E?c           	         | j                   d   j                         \  }}|t        u rM|j                  r@|j                  dk(  rI|j
                  dk(  rd|dz  z  d|dz  z  z
  d|z  z
  dz   S |j
                  dk(  rxd|dz  z  d	|z  z
  dz
  S |j                  dk(  rXt        |j
                        }|j                  r7t        | |      }t        |j                  |t        d|z
  dz        i            S t        |j
                        }t        |t              }t        |dz         D cg c]  }|||z
  z  ||   z   }}t!        | d
|j                  z  z
  }t#        |      \  }	}
t%        |
||       }|S t'        d| z        c c}w )zu
    Returns the minimal polynomial of ``cos(ex)``
    see https://mathworld.wolfram.com/TrigonometryAngles.html
    r   r6         r   r   rB   r   r   ry   r   )rf   r   r   r   ri   r   r   r   r   r   rO   r   intr   r   rK   r   r#   rc   r   )r   rT   r   r`   r   r]   rJ   r>   r   r?   rS   r   s               r@   _minpoly_cosr     sr   
 771:""$DAqBw==ssax33!8QT6AadF?QqS014433!8QT6AaC<!++ACCL::$R+A#AFFAdAE19o+>$?@@ ACCAq"%A*/A,7QQUAaD7A7Q2)#A$QJAw !R0CJ
DrI
JJ 8s   +Fc                    | j                   d   j                         \  }}|t        u r|j                  r|dz  }t	        |j
                        }|j                  dz  dk(  r|nd}g }t        |j                  dz   dz  |dz   d      D ]7  }|j                  |||z  z         |||z
  dz
  z  ||z
  z   |dz   |dz   z  z  }9 t        | }t        |      \  }}	t        |	||       }
|
S t        d| z        )zk
    Returns the minimal polynomial of ``tan(ex)``
    see https://github.com/sympy/sympy/issues/21430
    r   rB   r6   r   )rf   r   r   r   r   r   ri   rK   r|   r   r#   rc   r   )r   rT   r   r`   rJ   r   r9   r   r?   rS   r   s              r@   _minpoly_tanr     s   
 771:""$DAqBw==AAACCASS1W\qAEACCE19ac1- 8Qq!tV$1Qi1o&AaC!A#;78 UA$QJAw !R0CJ
DrI
JJrl   c                    | j                   d   j                         \  }}|t        t        z  k(  r|j                  rt        |j                        }|j                  dk(  s|j                  dk(  r|dk(  r|dz  |z
  dz   S |dk(  r|dz  dz   S |dk(  r|dz  |dz  z
  dz   S |dk(  r|dz  dz   S |d	k(  r|dz  |dz  z
  dz   S |d
k(  r|dz  |dz  z
  |dz  z   |dz  z
  dz   S |j                  rd}t        |      D ]  }|| |z  z  } |S t        d|z        D cg c]  }t        ||       }}t        |||       }|S t        d| z        t        d| z        c c}w )z7
    Returns the minimal polynomial of ``exp(ex)``
    r   r6   ry   r   rB   r   r   r   r   r7   r   )rf   r   r
   r   r   r   r   ri   r   rK   r   r/   rc   r   )	r   rT   r   r`   r   r]   r>   rS   r   s	            r@   _minpoly_expr     s    771:""$DAqAbDy==Assax133"96a4!8a<'6a4!8O6a4!Q$;?*6a4!8O6a4!Q$;?*7a4!Q$;A-14q88::A"1X %qb1W%H 7?qsmDq!,DGDB/BILrQRR
DrI
JJ Es   Ec                     | j                   }|j                  | j                  j                  d   |i      }t	        ||      \  }}t        |||       }|S )zA
    Returns the minimal polynomial of a ``CRootOf`` object.
    r   )rq   rO   polyr   r#   rc   )r   rT   ri   r?   rS   r   s         r@   _minpoly_rootofr   
  sO     	A	Q"#AQ"JAwGQ+FMrl   c           	         | j                   r| j                  |z  | j                  z
  S | t        u r6t	        |dz  dz   ||      \  }}t        |      dk(  r|dz  dz   S |t        z
  S | t        j                  u rQt	        |dz  |z
  dz
  ||      \  }}t        |      dk(  r|dz  |z
  dz
  S t        ||dt        d      z   dz  |      S | t        j                  u rt	        |dz  |dz  z
  |z
  dz
  ||      \  }}t        |      dk(  r|dz  |dz  z
  |z
  dz
  S dt        ddt        d      z  z
        z   t        ddt        d      z  z         z   dz  }t        ||||      S t        |d	      r| |j                  v r|| z
  S |j                  r%t        |       r| |z  } 	 t!        |       }|| u r| S |} | j"                  rt%        ||g| j&                   }|S | j(                  rt+        |       j,                  }t/        |j1                         d
       }	|	d   rO|t2        k(  rEt5        |	d   |	d   z   D 
 cg c]
  \  }
} |
| z   c} }
 }t7        |	d         }|j9                         D cg c]  }|j                   }}t;        t<        |d      }t        j>                  }|jA                  |t        jB                        }|j1                         D cg c]$  \  }}||j                  |z  |j                  z  z  & }}}t5        | }tE        ||      }|j                  ||z  z  |j                  |||z  z  z  z
  }||z  |tG        d|      z  z  }tI        t4        ||||||      }|S tK        ||g| j&                   }|S | jL                  r$tO        | jP                  | jR                  ||      }|S | jT                  tV        u rtY        | |      }|S | jT                  tZ        u rt]        | |      }|S | jT                  t^        u rta        | |      }|S | jT                  tR        u rtc        | |      }|S | jT                  td        u rtg        | |      }|S ti        d| z        c c} }
w c c}w c c}}w )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

    rB   r6   r   r4   )rV   r      !   r8   c                 B    | d   j                   xr | d   j                   S )Nr   r6   )rg   )itxs    r@   rw   z"_minpoly_compose.<locals>.<lambda>K  s    A(:(:(Qs1v?Q?Q rl   TFN)r   r   r   )5rg   r   ri   r
   r#   rE   r   GoldenRatiorc   r   TribonacciConstantr   rF   r8   is_QQrk   r   re   r   rf   r{   r   rS   r2   itemsr   r	   dictvaluesr   r)   NegativeOnepopZerominimal_polynomialr   r   r   ro   r   baser   	__class__r   r   r   r   r   r   r   r.   r   r   )r   rT   rV   r?   rS   facr   r   rY   r   bxr1rj   denslcmdensneg1expn1r   numsr   r   r   s                         r@   r   r     s[     
~~ttAv}	Qw A1S9
7w<1,q!tax7!a%7	Q]] AAq=
7w<1a4!8a<!'1q47{Ao3GG	Q!!! A1q1!4aD
7w<1a4!Q$;?Q&&tB48O,,tB48O/DDIC!'1cs;;sI2#42v
yy]2&
ar"Cby	  
yy1c,BGG,L JK 
BKQRT7sbyQuX$-?@62rB@ACagB!#-AACC-D-S$*G==DFF4(E>@hhjI74D133w;!##-.IDIt*C$S!,C %%7
"SUU4%-+@%@@C+Xa%9 99C/S#q#3TWXC" J q#00C J 
277BFFAs3 J 
	2q! J 
	2q! J 
	2q! J 
	2q!
 J	 
	 b!$ J H2MNNA A- Js   :Q#
.Q))Q.c                 
   t        |       } | j                  rt        | d      } t        |       D ]  }|j                  sd} n |t        |      t
        }}nt        d      t        }}|s6| j                  r$t        t        t        | j                              }nt        }t        |d      r||j                  v rt        d|d|      |rtt        | ||      }|j!                         d   }|j#                  |t%        ||      z        }|j&                  rt)        |       }|r |||d	      S |j+                  |      S |j,                  st/        d
      t1        | ||      }|r |||d	      S |j+                  |      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)	recursiveFrT   r8   zthe variable z$ is an element of the ground domain r6   )fieldz!groebner method only works for QQ)r   rI   r   r   is_AlgebraicNumberr    r   r!   free_symbolsr   r   listrF   r8   r   r   r   r   r&   is_negativer   collectr   rR   _minpoly_groebner)	r   rT   r   polysr   rq   clsr   r   s	            r@   r   r   q  si   n 
B	||bD)"2& ""G
 	}T3sX3??"2tBOO'<=FFvy!a6>>&9-.8 9 	9 !"a0!!#A&LLF61--.==(F-2s61D)Iq8II<<!"EFFr1c*F).3vq%EFNN14EErl   c                    t        dt              i i cdfd	fdd }d}t        |       } | j                  r| j	                         j                        S | j                  r| j                  z  | j                  z
  }n ||       }|r| dz  } d}| j                  r@d	| j                  z  j                  r'd	| j                  z  }t        | j                  |      }n&t        |       rt        | t        j                         }||}|o |       }|z
  gt#        j%                               z   }	t'        |	t#        j%                               gz   d
      }
t)        |
d         \  }}t+        ||       }|r9t-              }|j/                  t1        |      z        dk  rt3        |       }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   Nc                 p    t              }|| <   |||z  |z   | <   |S  |j                  |      | <   |S r<   )nextrG   )r   r   r   r`   	generatormappingr8   s       r@   update_mappingz)_minpoly_groebner.<locals>.update_mapping  sM    OS&4-GBK  &#++a.GBKrl   c                    | j                   r4| t        j                  u r| 
vr
 | dd      S |    S | j                  r| S | j                  r&t        | j                  D cg c]
  } |       c} S | j                  r&t        | j                  D cg c]
  } |       c} S | j                  rh| j                  j                  r}| j                  dk  rt        | j                  	      }t        |      j                         }|j                  | j                        j!                         }| j                  dk(  r |      S || j                   z  } | j                  j"                  sR| j                  | j                  j$                  z  j!                         t'        d| j                  j(                        }}n| j                  | j                  }} |      }||z  }|
vr*|j"                  r|j!                         S  |d|z  |       S |   S | j*                  r | 
vr | | j-                               S |    S t/        d| z        c c}w c c}w )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.

        rB   r6   r   ry   z*%s does not seem to be an algebraic number)r~   r   ImaginaryUnitrg   re   r   rf   r{   r	   ro   r   r   r   r"   rG   rO   expandr   ri   r   r   r   minpoly_of_elementr   )r   r   minpoly_baseinversebase_invr   r   rq   bottom_up_scanr   r  r8   r  rT   s           r@   r  z)_minpoly_groebner.<locals>.bottom_up_scan  s   8 ::Q__$W$)"a33"2;&	YYRWW>.+>??YYRWW>.+>??YYvv!!66A:#4RWWa#EL$Q5==?G&||Arww7>>@Hvv|-h77%0vv(()668Xa5J D !##D%d+Syw&~~#{{},-dAGdUCC"4=("" %b"*?*?*ABBr{"G"LMMG ?>s   !IIc                 d   | j                   r?d| j                  z  j                  r&| j                  dk  r| j                  j                  ry| j
                  rYd}| j                  D ]E  }|j                  r y|j                   s|j                  j                  s5|j                  dkD  sE y |ryy)z
        Returns True if it is more likely that the minimal polynomial
        algorithm works better with the inverse
        r6   r   TF)ro   r   r   r   re   r{   rf   )r   hitri   s      r@   simpler_inversez*_minpoly_groebner.<locals>.simpler_inverse5  s    
 99"&&$$!77>>99CWW %88 88vv}}$% rl   Fry   r6   lex)orderr   r<   )r0   r   r   r   r  rG   rg   r   ri   ro   r   r   r   r   rk   r   r}   r   r   r$   r#   rc   r   r   r&   r   )r   rT   r   r  invertedr   r   rJ   busr   Gr?   rS   r  r  r  r8   r  s    ``          @@@@@r@   r   r     s    !%0I2GW	HN HNT, H	B	B	$$&..q11	a"$$"2&RB99!BFF(.."&&A(!Q7C2(QUUA6C?F; $CS	D!122AD!12aS8FA$QrU+JAw#GQ3F&!$<<6&!,,-1(FMrl   c                 "    t        | ||||      S )z6This is a synonym for :py:func:`~.minimal_polynomial`.)rT   r   r   r   )r   )r   rT   r   r   r   s        r@   minpolyr  p  s     bAweFSSrl   )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   rc   rk   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  ru   rl   r@   <module>r1     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Yx YF YFx_D T Trl   