§
    OŠtjP£  ã                   óŠ  — d Z ddlmZmZmZmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZ ddlmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z; ddl<m=Z=m>Z> ddl?m@Z@ ddlAmBZBmCZCmDZDmEZEmFZF d„ ZGd	„ ZHd
„ ZId„ ZJd„ ZKd„ ZLd„ ZMd„ ZNd„ ZOd„ ZPd„ ZQd„ ZRd„ ZSdBd„ZTd„ ZUd„ ZVd„ ZWd„ ZXd„ ZYd„ ZZd„ Z[dBd„Z\d„ Z]d „ Z^d!„ Z_d"„ Z`d#„ Zad$„ Zbd%„ Zcd&„ Zdd'„ Zed(„ Zfd)„ Zgd*Zhd+„ Zid,„ Zjd-„ Zkd.„ Zld/„ Zmd0„ Znd1„ Zod2„ Zpd3„ Zqd4„ Zrd5„ Zsd6„ Ztd7„ Zud8„ Zvd9„ Zwd:„ Zxd;„ Zyd<„ Zzd=„ Z{dCd?„Z|dCd@„Z}dAS )DzEEuclidean algorithms, GCDs, LCMs and polynomial remainder sequences. é    )Údup_sub_mulÚdup_negÚdmp_negÚdmp_addÚdmp_subÚdup_mulÚdmp_mulÚdmp_powÚdup_divÚdmp_divÚdup_remÚdup_quoÚdmp_quoÚdup_premÚdmp_premÚdup_mul_groundÚdmp_mul_groundÚdmp_mul_termÚdup_quo_groundÚdmp_quo_groundÚdup_max_normÚdmp_max_norm)Ú	dup_stripÚ	dmp_raiseÚdmp_zeroÚdmp_oneÚ
dmp_groundÚ	dmp_one_pÚ
dmp_zero_pÚ	dmp_zerosÚ
dup_degreeÚ
dmp_degreeÚdmp_degree_inÚdup_LCÚdmp_LCÚdmp_ground_LCÚdmp_multi_deflateÚdmp_inflateÚdup_convertÚdmp_convertÚdmp_apply_pairs)Údup_clear_denomsÚdmp_clear_denomsÚdup_diffÚdmp_diffÚdup_evalÚdmp_evalÚdmp_eval_inÚ	dup_truncÚdmp_ground_truncÚ	dup_monicÚdmp_ground_monicÚdup_primitiveÚdmp_ground_primitiveÚdup_extractÚdmp_ground_extract©Úgf_intÚgf_crt)Úquery)ÚMultivariatePolynomialErrorÚHeuristicGCDFailedÚHomomorphismFailedÚNotInvertibleÚDomainErrorc                 ó  — |j         st          d|z  ¦  «        ‚|j        gg }}|r.t          | ||¦  «        \  }}||}} |t	          ||||¦  «        }}|°.t          |t          | |¦  «        |¦  «        }t          | |¦  «        } || fS )ar  
    Half extended Euclidean algorithm in `F[x]`.

    Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
    >>> g = x**3 + x**2 - 4*x - 4

    >>> R.dup_half_gcdex(f, g)
    (-1/5*x + 3/5, x + 1)

    z(Cannot compute half extended GCD over %s)Úis_FieldrC   Úoner   r   r   r$   r5   )ÚfÚgÚKÚaÚbÚqÚrs          úU/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/polys/euclidtools.pyÚdup_half_gcdexrO   2   s¨   € ð& Œ:ð JÝÐDÀqÑHÑIÔIÐIàŒEˆ7�B€q€Aà
ð *Ý�q˜!˜QÑÔ‰ˆˆ1Ø�!ˆ1ˆØ•+˜a  A qÑ)Ô)ˆ1ˆð ð *õ
 	�q�&  A™,œ,¨Ñ*Ô*€AÝ�!�Q‰Œ€Aàˆaˆ4€Kó    c                 óH   — |st          | ||¦  «        S t          | |¦  «        ‚)z�
    Half extended Euclidean algorithm in `F[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rO   r?   ©rG   rH   ÚurI   s       rN   Údmp_half_gcdexrT   U   s.   € ð ð 0Ý˜a  AÑ&Ô&Ð&å)¨!¨QÑ/Ô/Ð/rP   c                 óz   — t          | ||¦  «        \  }}t          ||| |¦  «        }t          |||¦  «        }|||fS )a  
    Extended Euclidean algorithm in `F[x]`.

    Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15
    >>> g = x**3 + x**2 - 4*x - 4

    >>> R.dup_gcdex(f, g)
    (-1/5*x + 3/5, 1/5*x**2 - 6/5*x + 2, x + 1)

    )rO   r   r   )rG   rH   rI   ÚsÚhÚFÚts          rN   Ú	dup_gcdexrZ   f   sH   € õ& ˜!˜Q Ñ"Ô"�D€A€qå�A�q˜!˜QÑÔ€AÝ��1�aÑÔ€Aàˆa�ˆ7€NrP   c                 óH   — |st          | ||¦  «        S t          | |¦  «        ‚)z˜
    Extended Euclidean algorithm in `F[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rZ   r?   rR   s       rN   Ú	dmp_gcdexr\   �   s.   € ð ð 0Ý˜˜A˜qÑ!Ô!Ð!å)¨!¨QÑ/Ô/Ð/rP   c                 ó‚   — t          | ||¦  «        \  }}||j        gk    rt          |||¦  «        S t          d¦  «        ‚)at  
    Compute multiplicative inverse of `f` modulo `g` in `F[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**2 - 1
    >>> g = 2*x - 1
    >>> h = x - 1

    >>> R.dup_invert(f, g)
    -4/3

    >>> R.dup_invert(f, h)
    Traceback (most recent call last):
    ...
    NotInvertible: zero divisor

    zzero divisor)rO   rF   r   rB   )rG   rH   rI   rV   rW   s        rN   Ú
dup_invertr^   ’   sF   € õ. ˜!˜Q Ñ"Ô"�D€A€qàˆQŒUˆG‚|€|Ý�q˜!˜QÑÔÐå˜NÑ+Ô+Ð+rP   c                 óH   — |st          | ||¦  «        S t          | |¦  «        ‚)z¨
    Compute multiplicative inverse of `f` modulo `g` in `F[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    )r^   r?   rR   s       rN   Ú
dmp_invertr`   ±   s.   € ð ð 0Ý˜!˜Q Ñ"Ô"Ð"å)¨!¨QÑ/Ô/Ð/rP   c                 óŒ   — | |g}t          | ||¦  «        }|r,|                     |¦  «         ||}} t          | ||¦  «        }|°,|S )an  
    Euclidean polynomial remainder sequence (PRS) in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21

    >>> prs = R.dup_euclidean_prs(f, g)

    >>> prs[0]
    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> prs[1]
    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
    >>> prs[2]
    -5/9*x**4 + 1/9*x**2 - 1/3
    >>> prs[3]
    -117/25*x**2 - 9*x + 441/25
    >>> prs[4]
    233150/19773*x - 102500/6591
    >>> prs[5]
    -1288744821/543589225

    )r   Úappend)rG   rH   rI   ÚprsrW   s        rN   Údup_euclidean_prsrd   Â   s`   € ð: ˆaˆ&€CÝ��1�aÑÔ€Aà
ð Ø�
Š
�1‰ŒˆØ�!ˆ1ˆÝ�A�q˜!ÑÔˆð ð ð
 €JrP   c                 óH   — |st          | ||¦  «        S t          | |¦  «        ‚)z©
    Euclidean polynomial remainder sequence (PRS) in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rd   r?   rR   s       rN   Údmp_euclidean_prsrf   ê   ó.   € ð ð 0Ý   A qÑ)Ô)Ð)å)¨!¨QÑ/Ô/Ð/rP   c                 óÐ   — | |g}t          t          | ||¦  «        |¦  «        \  }}|r=|                     |¦  «         ||}} t          t          | ||¦  «        |¦  «        \  }}|°=|S )a;  
    Primitive polynomial remainder sequence (PRS) in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> f = x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> g = 3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21

    >>> prs = R.dup_primitive_prs(f, g)

    >>> prs[0]
    x**8 + x**6 - 3*x**4 - 3*x**3 + 8*x**2 + 2*x - 5
    >>> prs[1]
    3*x**6 + 5*x**4 - 4*x**2 - 9*x + 21
    >>> prs[2]
    -5*x**4 + x**2 - 3
    >>> prs[3]
    13*x**2 + 25*x - 49
    >>> prs[4]
    4663*x - 6150
    >>> prs[5]
    1

    )r7   r   rb   )rG   rH   rI   rc   Ú_rW   s         rN   Údup_primitive_prsrj   û   s|   € ð: ˆaˆ&€CÝ� ! Q¨Ñ*Ô*¨AÑ.Ô.�D€A€qà
ð 3Ø�
Š
�1‰ŒˆØ�!ˆ1ˆÝ�X a¨¨AÑ.Ô.°Ñ2Ô2‰ˆˆ1ð ð 3ð
 €JrP   c                 óH   — |st          | ||¦  «        S t          | |¦  «        ‚)z©
    Primitive polynomial remainder sequence (PRS) in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    )rj   r?   rR   s       rN   Údmp_primitive_prsrl   #  rg   rP   c                 ó¢  — t          | ¦  «        }t          |¦  «        }||k     r|| }} ||}}| sg g fS |s| g|j        gfS | |g}||z
  }|j         |dz   z  }t          | ||¦  «        }t          |||¦  «        }t	          ||¦  «        }	|	|z  }
|j        |
g}|
 }
|r±t          |¦  «        }|                     |¦  «         |||||z
  f\  } }}}|	 |
|z  z  }t          | ||¦  «        }t          |||¦  «        }t	          ||¦  «        }	|dk    r#|
|dz
  z  }|                     |	 |z  |¦  «        }
n|	 }
|                     |
 ¦  «         |°±||fS )a  
    Subresultant PRS algorithm in `K[x]`.

    Computes the subresultant polynomial remainder sequence (PRS)
    and the non-zero scalar subresultants of `f` and `g`.
    By [1] Thm. 3, these are the constants '-c' (- to optimize
    computation of sign).
    The first subdeterminant is set to 1 by convention to match
    the polynomial and the scalar subdeterminants.
    If 'deg(f) < deg(g)', the subresultants of '(g,f)' are computed.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_inner_subresultants(x**2 + 1, x**2 - 1)
    ([x**2 + 1, x**2 - 1, -2], [1, 1, 4])

    References
    ==========

    .. [1] W.S. Brown, The Subresultant PRS Algorithm.
           ACM Transaction of Mathematical Software 4 (1978) 237-249

    é   )r!   rF   r   r   r$   rb   r   Úquo)rG   rH   rI   ÚnÚmÚRÚdrK   rW   ÚlcÚcÚSÚkrL   s                 rN   Údup_inner_subresultantsrx   4  s¥  € õ8 	�1‰Œ€AÝ�1‰Œ€Aàˆ1‚u€uØ�!ˆ1ˆØ�!ˆ1ˆàð Ø�2ˆvˆàð Øˆs�Q”U�Gˆ|Ðà	
ˆAˆ€AØ	ˆA‰€Aà
Œ%ˆ�1�q‘5Ñ€Aå��A�qÑÔ€AÝ�q˜!˜QÑÔ€Aå	��1‰Œ€BØ
ˆA‰€Að 
Œ�ˆ
€AØ	
ˆ€Aà
ð Ý�q‰MŒMˆØ	�Š�‰Œˆà˜˜1˜a !™e�^‰
ˆˆ1ˆa�àˆC�!�Q‘$‰Jˆå�Q˜˜1ÑÔˆÝ˜1˜a Ñ#Ô#ˆå�A�q‰\Œ\ˆàˆqŠ5ˆ5Ø�A˜‘E‘
ˆAØ—’˜�s˜Q‘h Ñ"Ô"ˆAˆAà�ˆAà	�Š�!�‰Œˆð' ð ð* ˆaˆ4€KrP   c                 ó0   — t          | ||¦  «        d         S )zò
    Computes subresultant PRS of two polynomials in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_subresultants(x**2 + 1, x**2 - 1)
    [x**2 + 1, x**2 - 1, -2]

    r   )rx   ©rG   rH   rI   s      rN   Údup_subresultantsr{   „  s   € õ # 1 a¨Ñ+Ô+¨AÔ.Ð.rP   c                 óœ   — | r|s	|j         g fS t          | ||¦  «        \  }}t          |d         ¦  «        dk    r	|j         |fS |d         |fS )zõ
    Resultant algorithm in `K[x]` using subresultant PRS.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_prs_resultant(x**2 + 1, x**2 - 1)
    (4, [x**2 + 1, x**2 - 1, -2])

    éÿÿÿÿr   )Úzerorx   r!   )rG   rH   rI   rr   rv   s        rN   Údup_prs_resultantr   •  sd   € ð ð �Að Ø”˜ˆ|Ðå" 1 a¨Ñ+Ô+�D€A€qå�!�B”%ÑÔ˜1ÒÐØ”˜ˆ{ÐàˆRŒ5�!ˆ8€OrP   Fc                 óV   — |rt          | ||¦  «        S t          | ||¦  «        d         S )zÐ
    Computes resultant of two polynomials in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_resultant(x**2 + 1, x**2 - 1)
    4

    r   )r   )rG   rH   rI   Ú
includePRSs       rN   Údup_resultantr‚   ®  s5   € ð ð *Ý   A qÑ)Ô)Ð)Ý˜Q  1Ñ%Ô% aÔ(Ð(rP   c           	      óÐ  ‡‡‡— |st          | |‰¦  «        S t          | |¦  «        }t          ||¦  «        }||k     r|| }} ||}}t          | |¦  «        rg g fS |dz
  Št          ||¦  «        r| gt          ‰j        ‰¦  «        gfS | |g}||z
  }t          t          ‰j         ‰¦  «        |dz   ‰‰¦  «        Št          | ||‰¦  «        }t          |‰d|‰¦  «        }t          |‰¦  «        }	t          |	|‰‰¦  «        }
t          ‰j        ‰¦  «        |
g}t          |
‰‰¦  «        }
t          ||¦  «        �s+t          ||¦  «        }| 
                    |¦  «         |||||z
  f\  } }}}t          t          |	‰‰¦  «        t          |
|‰‰¦  «        ‰‰¦  «        Št          | ||‰¦  «        }ˆˆˆfd„|D ¦   «         }t          |‰¦  «        }	|dk    rIt          t          |	‰‰¦  «        |‰‰¦  «        }t          |
|dz
  ‰‰¦  «        }t          ||‰‰¦  «        }
nt          |	‰‰¦  «        }
| 
                    t          |
‰‰¦  «        ¦  «         t          ||¦  «        �¯+||fS )a  
    Subresultant PRS algorithm in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> a = 3*x*y**4 + y**3 - 27*y + 4
    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    >>> prs = [f, g, a, b]
    >>> sres = [[1], [1], [3, 0, 0, 0, 0], [-3, 0, 0, -12, 1, 0, -54, 8, 729, -216, 16]]

    >>> R.dmp_inner_subresultants(f, g) == (prs, sres)
    True

    rn   r   c                 ó4   •— g | ]}t          |‰‰‰¦  «        ‘ŒS © ©r   )Ú.0ÚchrI   rK   Úvs     €€€rN   ú
<listcomp>z+dmp_inner_subresultants.<locals>.<listcomp>  s'   ø€ Ð0Ð0Ð0 r�g�b˜!˜Q Ñ"Ô"Ð0Ð0Ð0rP   )rx   r"   r   r   rF   r
   r   r   r%   r   rb   r	   r   )rG   rH   rS   rI   rp   rq   rr   rs   rW   rt   ru   rv   rw   ÚprL   rK   r‰   s      `           @@rN   Údmp_inner_subresultantsrŒ   Á  s°  øøø€ ð. ð 0Ý& q¨!¨QÑ/Ô/Ð/å�1�aÑÔ€AÝ�1�aÑÔ€Aàˆ1‚u€uØ�!ˆ1ˆØ�!ˆ1ˆå�!�QÑÔð Ø�2ˆvˆà	ˆA‰€AÝ�!�QÑÔð +Øˆs•Z ¤ qÑ)Ô)Ð*Ð*Ð*à	
ˆAˆ€AØ	ˆA‰€Aå•
˜AœE˜6 1Ñ%Ô% q¨1¡u¨a°Ñ3Ô3€Aå��A�q˜!ÑÔ€AÝ�Q˜˜1˜a Ñ#Ô#€Aå	��1‰Œ€BÝ��A�q˜!ÑÔ€Aå	�A”E˜1Ñ	Ô	˜qÐ!€AÝ��1�aÑÔ€Aå˜˜AÑÔñ #Ý�q˜!ÑÔˆØ	�Š�‰Œˆà˜˜1˜a !™e�^‰
ˆˆ1ˆa�å•G˜B  1Ñ%Ô%Ý˜A˜q ! QÑ'Ô'¨¨Añ/ô /ˆõ �Q˜˜1˜aÑ Ô ˆØ0Ð0Ð0Ð0Ð0Ð0¨QÐ0Ñ0Ô0ˆå�A�q‰\Œ\ˆàˆqŠ5ˆ5Ý�  A qÑ)Ô)¨1¨a°Ñ3Ô3ˆAÝ˜˜1˜q™5 ! QÑ'Ô'ˆAÝ˜˜1˜a Ñ#Ô#ˆAˆAå˜˜A˜qÑ!Ô!ˆAà	�Š•˜˜A˜qÑ!Ô!Ñ"Ô"Ð"õ+ ˜˜AÑÔñ #ð. ˆaˆ4€KrP   c                 ó2   — t          | |||¦  «        d         S )aœ  
    Computes subresultant PRS of two polynomials in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> a = 3*x*y**4 + y**3 - 27*y + 4
    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    >>> R.dmp_subresultants(f, g) == [f, g, a, b]
    True

    r   )rŒ   rR   s       rN   Údmp_subresultantsrŽ     s   € õ( # 1 a¨¨AÑ.Ô.¨qÔ1Ð1rP   c                 ó*  — |st          | ||¦  «        S t          | |¦  «        st          ||¦  «        rt          |dz
  ¦  «        g fS t          | |||¦  «        \  }}t	          |d         |¦  «        dk    rt          |dz
  ¦  «        |fS |d         |fS )a  
    Resultant algorithm in `K[X]` using subresultant PRS.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> a = 3*x*y**4 + y**3 - 27*y + 4
    >>> b = -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    >>> res, prs = R.dmp_prs_resultant(f, g)

    >>> res == b             # resultant has n-1 variables
    False
    >>> res == b.drop(x)
    True
    >>> prs == [f, g, a, b]
    True

    rn   r}   r   )r   r   r   rŒ   r"   )rG   rH   rS   rI   rr   rv   s         rN   Údmp_prs_resultantr�   (  s¨   € ð4 ð *Ý   A qÑ)Ô)Ð)å�!�QÑÔð %�: a¨Ñ+Ô+ð %Ý˜˜Q™‘” Ð$Ð$å" 1 a¨¨AÑ.Ô.�D€A€qå�!�B”%˜ÑÔ˜aÒÐÝ˜˜Q™‘” Ð#Ð#àˆRŒ5�!ˆ8€OrP   c           	      ó°  — |s(t          t          | ||¦  «        d         |z  |¦  «        S |dz
  }t          | |¦  «        }t          ||¦  «        }t          | d|¦  «        }t          |d|¦  «        }	||	z  ||z  z   }
|j        g|j         }}t          |¦  «        }t          |¦  «        |
k    �r¦	 ||j        z  }||k    rt          d¦  «        ‚t          | t          ||¦  «        d||¦  «        }t          ||¦  «        |k    r6t          |t          ||¦  «        d||¦  «        }t          ||¦  «        |k    rnŒ‹t          |||||¦  «        }t          ||||¦  «        }|s!t          |g¦  «        }t          |g¦  «        }n|g}|g}|                     t          |||¦  «        |¦  «        }t          |||¦  «        }t          ||d|¦  «        }t!          |t#          ||||¦  «        ||¦  «        }t%          ||||¦  «        }t'          ||||¦  «        }t)          ||j        | g|¦  «        }t+          |||¦  «        }t          |¦  «        |
k    �°¦|S )a  
    Compute resultant of `f` and `g` modulo a prime `p`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x + y + 2
    >>> g = 2*x*y + x + 3

    >>> R.dmp_zz_modular_resultant(f, g, 5)
    -2*y**2 + 1

    r   rn   Túno luck)r<   r   r"   r#   rF   r   r!   rA   r2   Údmp_zz_modular_resultantr1   r   Úinvertr0   r   r   r	   r   r   r4   r   r3   )rG   rH   r‹   rS   rI   r‰   rp   rq   ÚNÚMÚBÚDrJ   rM   rX   ÚGrr   Úers   ru   s                       rN   r“   r“   P  sy  € ð" ð <ÝÕ'¨¨1¨aÑ0Ô0°Ô3°aÑ7¸Ñ;Ô;Ð;à	ˆA‰€Aå�1�aÑÔ€AÝ�1�aÑÔ€Aå�a˜˜AÑÔ€AÝ�a˜˜AÑÔ€Aà	ˆ!‰ˆa�‰c‰	€AàŒEˆ7�Q”U�F€q€AÝ�‰Œ€Aå
�Q‰-Œ-˜1Ò
Ñ
ð	Ø�”‰JˆAà�AŠvˆvÝ(¨Ñ3Ô3Ð3å˜A�v a¨™|œ|¨Q°°1Ñ5Ô5ˆAå˜!˜QÑÔ 1Ò$Ð$Ý ¥6¨!¨Q¡<¤<°°A°qÑ9Ô9�å˜a Ñ#Ô# qÒ(Ð(Øð	õ % Q¨¨1¨a°Ñ3Ô3ˆÝ�Q˜˜1˜aÑ Ô ˆàð 	Ý˜1˜#‘”ˆAÝ˜1˜#‘”ˆAˆAà�ˆAØ�ˆAà�HŠH•X˜a  AÑ&Ô&¨Ñ*Ô*ˆÝ˜1˜a Ñ#Ô#ˆÝ�a˜˜A˜qÑ!Ô!ˆå�A•w˜q ! Q¨Ñ*Ô*¨A¨qÑ1Ô1ˆÝ�A�q˜!˜QÑÔˆå˜Q  1 aÑ(Ô(ˆå�A˜œ ˜r�{ AÑ&Ô&ˆÝ�a˜˜AÑÔˆõG �Q‰-Œ-˜1Ò
Ñ
ðJ €HrP   c                 óN   — t          t          | |g||g|¦  «        ||z  ¦  «        S )z2Wrapper of CRT for Collins's resultant algorithm. r;   )rM   rr   ÚPr‹   rI   s        rN   Ú_collins_crtr�   ™  s*   € å•&˜!˜Q˜ ! Q ¨Ñ+Ô+¨Q¨q©SÑ1Ô1Ð1rP   c                 ó`  — t          | |¦  «        }t          ||¦  «        }|dk     s|dk     rt          |dz
  ¦  «        S t          | ||¦  «        }t          |||¦  «        }t          | ||¦  «        }t          |||¦  «        }	|dz
  }
 |d¦  «        |                      |||z   ¦  «        ¦  «        z  ||z  z  ||z  z  }t          |
¦  «        |j        |j        }}}ddlm} ||k    rÄ | ||¦  «        ¦  «        }||z  r|	|z  s | ||¦  «        ¦  «        }||z  ¯|	|z  ¯t          | |||¦  «        }t          ||||¦  «        }	 t          |||||¦  «        }n# t          $ r Y Œ‡w xY w|                     |¦  «        r|}nt          ||t          |||f|
|¦  «        }||z  }||k    °Ä|S )a  
    Collins's modular resultant algorithm in `Z[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x + y + 2
    >>> g = 2*x*y + x + 3

    >>> R.dmp_zz_collins_resultant(f, g)
    -2*y**2 - 5*y + 1

    r   rn   é   )Ú	nextprime)r"   r   r   r&   Ú	factorialrF   Úsympy.ntheoryr    r4   r“   rA   Úis_oner+   r�   )rG   rH   rS   rI   rp   rq   ÚAr—   rJ   rK   r‰   rM   r‹   rœ   r    rX   r™   rr   s                     rN   Údmp_zz_collins_resultantr¥   ž  s  € õ$ 	�1�aÑÔ€AÝ�1�aÑÔ€Aàˆ1‚u€u��A’�Ý˜˜A™‰ŒÐå�Q˜˜1ÑÔ€AÝ�Q˜˜1ÑÔ€Aå�a˜˜AÑÔ€AÝ�a˜˜AÑÔ€Aà	ˆA‰€Aà	ˆˆ!‰ŒˆQ�[Š[˜˜˜1˜q™5™œÑ"Ô"Ñ" 1 a¡4Ñ'¨¨1©Ñ,€AÝ�q‰kŒk˜1œ5 !¤%ˆ!€q€Aà'Ð'Ð'Ð'Ð'Ð'à
ˆqŠ&ˆ&ØˆAˆiˆi˜‰lŒl‰OŒOˆà�q‘5ð 	  ! a¡%ð 	 Ø��)�)˜A‘,”,‘”ˆAð �q‘5ð 	  ! a¡%ð 	 õ ˜Q  1 aÑ(Ô(ˆÝ˜Q  1 aÑ(Ô(ˆð	Ý(¨¨A¨q°!°QÑ7Ô7ˆAˆAøÝ!ð 	ð 	ð 	ØˆHð	øøøð �8Š8�A‰;Œ;ð 	EØˆAˆAå  1¥l°Q¸¸1°I¸qÀ!ÑDÔDˆAà	ˆQ‰ˆð' ˆqŠ&ˆ&ð* €Hs   ÅE Å
E,Å+E,c                 óø  — t          | |¦  «        }t          ||¦  «        }|dk     s|dk     rt          |dz
  ¦  «        S |                     ¦   «         }t          | |||¦  «        \  }} t          ||||¦  «        \  }}t	          | |||¦  «        } t	          ||||¦  «        }t          | |||¦  «        }	t	          |	|dz
  ||¦  «        }	|                     ||z  ||z  z  |¦  «        }
t          |	|
|dz
  |¦  «        S )a$  
    Collins's modular resultant algorithm in `Q[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y = ring("x,y", QQ)

    >>> f = QQ(1,2)*x + y + QQ(2,3)
    >>> g = 2*x*y + x + 3

    >>> R.dmp_qq_collins_resultant(f, g)
    -2*y**2 - 7/3*y + 5/6

    r   rn   )r"   r   Úget_ringr-   r*   r¥   Úconvertr   )rG   rH   rS   ÚK0rp   rq   ÚK1ÚcfÚcgrM   ru   s              rN   Údmp_qq_collins_resultantr­   Û  s  € õ" 	�1�aÑÔ€AÝ�1�aÑÔ€Aàˆ1‚u€u��A’�Ý˜˜A™‰ŒÐà	�Š‰Œ€Bå˜Q  2 rÑ*Ô*�E€BˆÝ˜Q  2 rÑ*Ô*�E€Bˆå�A�q˜"˜bÑ!Ô!€AÝ�A�q˜"˜bÑ!Ô!€Aå   A q¨"Ñ-Ô-€AÝ�A�q˜1‘u˜b "Ñ%Ô%€Aà
�
Š
�2�q‘5˜2˜q™5‘= "Ñ%Ô%€Aå˜!˜Q  A¡ rÑ*Ô*Ð*rP   c                 ó4  — |st          | |||¬¦  «        S |rt          | |||¦  «        S |j        r)|j        r!t	          d¦  «        rt          | |||¦  «        S n(|j        r!t	          d¦  «        rt          | |||¦  «        S t          | |||¦  «        d         S )aH  
    Computes resultant of two polynomials in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y - y**3 - 4
    >>> g = x**2 + x*y**3 - 9

    >>> R.dmp_resultant(f, g)
    -3*y**10 - 12*y**7 + y**6 - 54*y**4 + 8*y**3 + 729*y**2 - 216*y + 16

    )r�   ÚUSE_COLLINS_RESULTANTr   )r‚   r�   rE   Úis_QQr>   r­   Úis_ZZr¥   )rG   rH   rS   rI   r�   s        rN   Údmp_resultantr²     s¿   € ð" ð =Ý˜Q  1°Ð<Ñ<Ô<Ð<àð -Ý   A q¨!Ñ,Ô,Ð,à„zð 8ØŒ7ð 	8•uÐ4Ñ5Ô5ð 	8Ý+¨A¨q°!°QÑ7Ô7Ð7øàŒ7ð 	8•uÐ4Ñ5Ô5ð 	8Ý+¨A¨q°!°QÑ7Ô7Ð7å˜Q  1 aÑ(Ô(¨Ô+Ð+rP   c                 óú   — t          | ¦  «        }|dk    r|j        S d||dz
  z  dz  z  }t          | |¦  «        }t          | t	          | d|¦  «        |¦  «        }|                     || ||¦  «        z  ¦  «        S )zÐ
    Computes discriminant of a polynomial in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_discriminant(x**2 + 2*x + 3)
    -8

    r   r}   rn   rŸ   )r!   r~   r$   r‚   r.   ro   )rG   rI   rs   rV   ru   rM   s         rN   Údup_discriminantr´   #  s€   € õ 	�1‰Œ€AàˆA‚v€vØŒvˆà�A�q˜1‘u‘I !Ñ#Ñ$ˆÝ�1�a‰LŒLˆå˜!�X a¨¨AÑ.Ô.°Ñ2Ô2ˆà�uŠu�Q˜˜!˜!˜A™$œ$™ÑÔÐrP   c           	      óT  — |st          | |¦  «        S t          | |¦  «        |dz
  }}|dk    rt          |¦  «        S d||dz
  z  dz  z  }t          | |¦  «        }t	          | t          | d||¦  «        ||¦  «        }t          | ||¦  «        ||¦  «        }t          ||||¦  «        S )zé
    Computes discriminant of a polynomial in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y,z,t = ring("x,y,z,t", ZZ)

    >>> R.dmp_discriminant(x**2*y + x*z + t)
    -4*y*t + z**2

    rn   r   r}   rŸ   )r´   r"   r   r%   r²   r/   r   r   )rG   rS   rI   rs   r‰   rV   ru   rM   s           rN   Údmp_discriminantr¶   >  s¼   € ð ð &Ý  1Ñ%Ô%Ð%å�a˜ÑÔ˜Q ™U€q€AàˆA‚v€vÝ˜‰{Œ{Ðà�A�q˜1‘u‘I !Ñ#Ñ$ˆÝ�1�a‰LŒLˆå˜!�X a¨¨A¨qÑ1Ô1°1°aÑ8Ô8ˆÝ˜1˜a˜a ™dœd A qÑ)Ô)ˆå�q˜!˜Q Ñ"Ô"Ð"rP   c                 ó@  — | s|sg g g fS | sH|                      t          ||¦  «        ¦  «        r|g |j        gfS t          ||¦  «        g |j         gfS |sH|                      t          | |¦  «        ¦  «        r| |j        gg fS t          | |¦  «        |j         gg fS dS )ú3Handle trivial cases in GCD algorithm over a ring. N)Úis_nonnegativer$   rF   r   rz   s      rN   Ú_dup_rr_trivial_gcdrº   ]  sÄ   € àð /�ð /Ø�2�rˆzÐØð 	/Ø×Ò�F 1 a™LœLÑ)Ô)ð 	/Ø�b˜1œ5˜'�>Ð!å˜1˜a‘=”= "¨¬ v hÐ.Ð.Øð /Ø×Ò�F 1 a™LœLÑ)Ô)ð 	/Ø�q”u�g˜r�>Ð!å˜1˜a‘=”= A¤E 6 (¨BÐ.Ð.àˆ4rP   c                 ó¨   — | s|sg g g fS | s"t          ||¦  «        g t          ||¦  «        gfS |s"t          | |¦  «        t          | |¦  «        gg fS dS )ú4Handle trivial cases in GCD algorithm over a field. N)r5   r$   rz   s      rN   Ú_dup_ff_trivial_gcdr½   o  sp   € àð �ð Ø�2�rˆzÐØð Ý˜˜A‰Œ ¥V¨A¨q¡\¤\ NÐ2Ð2Øð Ý˜˜A‰Œ¥¨¨1¡¤ °Ð2Ð2àˆtrP   c                 ó&  — t          | |¦  «        }t          ||¦  «        }t          | ||¦  «        pt          |||¦  «        }|r |rt          t          d||¦  «        ¦  «        S |ry|                     t          |||¦  «        ¦  «        r |t          |¦  «        t          ||¦  «        fS t          |||¦  «        t          |¦  «        t          |j
         |¦  «        fS |ry|                     t          | ||¦  «        ¦  «        r | t          ||¦  «        t          |¦  «        fS t          | ||¦  «        t          |j
         |¦  «        t          |¦  «        fS |rt          ||¦  «        | |fS t          d¦  «        rt          | |||¦  «        S dS )r¸   é   ÚUSE_SIMPLIFY_GCDN)r   r   Útupler    r¹   r&   r   r   r   r   rF   r>   Ú_dmp_simplify_gcd)rG   rH   rS   rI   Úzero_fÚzero_gÚif_contain_ones          rN   Ú_dmp_rr_trivial_gcdrÆ   {  s˜  € å˜˜1ÑÔ€FÝ˜˜1ÑÔ€FÝ˜q ! QÑ'Ô'Ð=­9°Q¸¸1Ñ+=Ô+=€Nàð �&ð Ý•Y˜q ! QÑ'Ô'Ñ(Ô(Ð(Ø	ð Ø×Ò�M¨!¨Q°Ñ2Ô2Ñ3Ô3ð 	HØ•h˜q‘k”k¥7¨1¨a¡=¤=Ð0Ð0å˜1˜a Ñ#Ô#¥X¨a¡[¤[µ*¸a¼e¸VÀQÑ2GÔ2GÐGÐGØ	ð 
Ø×Ò�M¨!¨Q°Ñ2Ô2Ñ3Ô3ð 	HØ•g˜a ‘m”m¥X¨a¡[¤[Ð0Ð0å˜1˜a Ñ#Ô#¥Z°´°¸Ñ%:Ô%:½HÀQ¹K¼KÐGÐGØ	ð Ý�q˜!‰}Œ}˜a Ð"Ð"Ý	Ð!Ñ	"Ô	"ð Ý   A q¨!Ñ,Ô,Ð,àˆtrP   c           	      óÌ  — t          | |¦  «        }t          ||¦  «        }|r |rt          t          d||¦  «        ¦  «        S |r>t          |||¦  «        t	          |¦  «        t          t          |||¦  «        |¦  «        fS |r>t          | ||¦  «        t          t          | ||¦  «        |¦  «        t	          |¦  «        fS t          d¦  «        rt          | |||¦  «        S dS )r¼   r¿   rÀ   N)	r   rÁ   r    r6   r   r   r&   r>   rÂ   )rG   rH   rS   rI   rÃ   rÄ   s         rN   Ú_dmp_ff_trivial_gcdrÈ   •  sý   € å˜˜1ÑÔ€FÝ˜˜1ÑÔ€Fàð �&ð Ý•Y˜q ! QÑ'Ô'Ñ(Ô(Ð(Ø	ð Ý   A qÑ)Ô)Ý˜‘”Ý�=¨¨A¨qÑ1Ô1°1Ñ5Ô5ð7ð 	7ð 
ð Ý   A qÑ)Ô)Ý�=¨¨A¨qÑ1Ô1°1Ñ5Ô5Ý˜‘”ðð 	õ 
Ð!Ñ	"Ô	"ð Ý   A q¨!Ñ,Ô,Ð,àˆtrP   c                 ó²  ‡‡
‡— t          | |¦  «        }t          ||¦  «        }|dk    r|dk    rdS |s#|s!t          | ‰¦  «        }t          |‰¦  «        }nE|s"t          | ‰¦  «        }t          ||‰¦  «        }n!t          | |‰¦  «        }t          |‰¦  «        }|dz
  Št          ||‰‰¦  «        Š
ˆˆ
ˆfd„| D ¦   «         }ˆˆ
ˆfd„|D ¦   «         }	‰
g||	fS )z7Try to eliminate `x_0` from GCD computation in `K[X]`. r   Nrn   c                 ó4   •— g | ]}t          |‰‰‰¦  «        ‘ŒS r…   r†   )r‡   r«   rI   rW   r‰   s     €€€rN   rŠ   z%_dmp_simplify_gcd.<locals>.<listcomp>À  ó'   ø€ Ð
.Ð
.Ð
. R�G�B˜˜1˜aÑ Ô Ð
.Ð
.Ð
.rP   c                 ó4   •— g | ]}t          |‰‰‰¦  «        ‘ŒS r…   r†   )r‡   r¬   rI   rW   r‰   s     €€€rN   rŠ   z%_dmp_simplify_gcd.<locals>.<listcomp>Á  rË   rP   )r"   r%   Údmp_contentÚdmp_gcd)rG   rH   rS   rI   ÚdfÚdgrX   r™   ÚcffÚcfgrW   r‰   s      `      @@rN   rÂ   rÂ   ª  s  øøø€ å	�A�qÑ	Ô	€BÝ	�A�qÑ	Ô	€Bà	ˆA‚v€v�"�q’&�&Øˆtàð 	�"ð 	Ý�1�a‰LŒLˆÝ�1�a‰LŒLˆˆàð 	Ý�q˜!‘”ˆAÝ˜A˜q !Ñ$Ô$ˆAˆAå˜A˜q !Ñ$Ô$ˆAÝ�q˜!‘”ˆAà	ˆA‰€AÝ��1�a˜ÑÔ€Aà
.Ð
.Ð
.Ð
.Ð
.Ð
.¨1Ð
.Ñ
.Ô
.€CØ
.Ð
.Ð
.Ð
.Ð
.Ð
.¨1Ð
.Ñ
.Ô
.€Càˆ3��Sˆ=ÐrP   c                 ó´  — t          | ||¦  «        }|�|S t          | |¦  «        \  }}t          ||¦  «        \  }}|                     ||¦  «        }t          |||¦  «        d         }	t          |	|¦  «        \  }
}	||                     t          |	|¦  «        ¦  «        z  }t          |	||¦  «        }	t          | |	|¦  «        }t          ||	|¦  «        }|	||fS )aa  
    Computes polynomial GCD using subresultants over a ring.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_rr_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    Nr}   )rº   r7   Úgcdr{   Úcanonical_unitr$   r   r   )rG   rH   rI   ÚresultÚfcrX   Úgcr™   ru   rW   ri   rÑ   rÒ   s                rN   Údup_rr_prs_gcdrÙ   Æ  sß   € õ" !  A qÑ)Ô)€FàÐØˆå˜!˜QÑÔ�E€BˆÝ˜!˜QÑÔ�E€Bˆà	�Šˆb�"‰Œ€Aå˜!˜Q Ñ"Ô" 2Ô&€AÝ˜˜AÑÔ�D€A€qàˆ×	Ò	�&  A™,œ,Ñ	'Ô	'Ñ'€Aå�q˜!˜QÑÔ€Aå
�!�Q˜Ñ
Ô
€CÝ
�!�Q˜Ñ
Ô
€Càˆc�3ˆ;ÐrP   c                 óÈ   — t          | ||¦  «        }|�|S t          | ||¦  «        d         }t          ||¦  «        }t          | ||¦  «        }t          |||¦  «        }|||fS )ab  
    Computes polynomial GCD using subresultants over a field.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> R.dup_ff_prs_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    Nr}   )r½   r{   r5   r   )rG   rH   rI   rÖ   rW   rÑ   rÒ   s          rN   Údup_ff_prs_gcdrÛ   î  sq   € õ" !  A qÑ)Ô)€FàÐØˆå˜!˜Q Ñ"Ô" 2Ô&€AÝ�!�Q‰Œ€Aå
�!�Q˜Ñ
Ô
€CÝ
�!�Q˜Ñ
Ô
€Càˆc�3ˆ;ÐrP   c                 ó(  — |st          | ||¦  «        S t          | |||¦  «        }|�|S t          | ||¦  «        \  }}t          |||¦  «        \  }}t          ||||¦  «        d         }	t	          |||dz
  |¦  «        \  }
}}t          |	||¦  «        \  }}	t          |	|
d||¦  «        }	|                     t          |	||¦  «        ¦  «        }||j        k    rt          |	|||¦  «        }	t          | |	||¦  «        }t          ||	||¦  «        }|	||fS )a†  
    Computes polynomial GCD using subresultants over a ring.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_rr_prs_gcd(f, g)
    (x + y, x + y, x)

    Nr}   rn   r   )rÙ   rÆ   Údmp_primitiverŽ   Údmp_rr_prs_gcdr   rÕ   r&   rF   r   r   )rG   rH   rS   rI   rÖ   r×   rX   rØ   r™   rW   ru   ri   ÚunitrÑ   rÒ   s                  rN   rÞ   rÞ     s4  € ð( ð 'Ý˜a  AÑ&Ô&Ð&å   A q¨!Ñ,Ô,€FàÐØˆå˜!˜Q Ñ"Ô"�E€BˆÝ˜!˜Q Ñ"Ô"�E€Bˆå˜!˜Q  1Ñ%Ô% bÔ)€AÝ˜R  Q¨¡U¨AÑ.Ô.�G€A€qˆ!å˜˜A˜qÑ!Ô!�D€A€qÝ�Q˜˜1˜a Ñ#Ô#€Aà×Ò�M¨!¨Q°Ñ2Ô2Ñ3Ô3€DàˆqŒu‚}€}Ý˜1˜d A qÑ)Ô)ˆå
�!�Q˜˜1Ñ
Ô
€CÝ
�!�Q˜˜1Ñ
Ô
€Càˆc�3ˆ;ÐrP   c                 óÈ  — |st          | ||¦  «        S t          | |||¦  «        }|�|S t          | ||¦  «        \  }}t          |||¦  «        \  }}t          ||||¦  «        d         }	t	          |||dz
  |¦  «        \  }
}}t          |	||¦  «        \  }}	t          |	|
d||¦  «        }	t          |	||¦  «        }	t          | |	||¦  «        }t          ||	||¦  «        }|	||fS )a�  
    Computes polynomial GCD using subresultants over a field.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``, ``cff = quo(f, h)``,
    and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y, = ring("x,y", QQ)

    >>> f = QQ(1,2)*x**2 + x*y + QQ(1,2)*y**2
    >>> g = x**2 + x*y

    >>> R.dmp_ff_prs_gcd(f, g)
    (x + y, 1/2*x + 1/2*y, x)

    Nr}   rn   r   )rÛ   rÈ   rÝ   rŽ   Údmp_ff_prs_gcdr   r6   r   )rG   rH   rS   rI   rÖ   r×   rX   rØ   r™   rW   ru   ri   rÑ   rÒ   s                 rN   rá   rá   =  s  € ð( ð 'Ý˜a  AÑ&Ô&Ð&å   A q¨!Ñ,Ô,€FàÐØˆå˜!˜Q Ñ"Ô"�E€BˆÝ˜!˜Q Ñ"Ô"�E€Bˆå˜!˜Q  1Ñ%Ô% bÔ)€AÝ˜R  Q¨¡U¨AÑ.Ô.�G€A€qˆ!å˜˜A˜qÑ!Ô!�D€A€qÝ�Q˜˜1˜a Ñ#Ô#€AÝ˜˜A˜qÑ!Ô!€Aå
�!�Q˜˜1Ñ
Ô
€CÝ
�!�Q˜˜1Ñ
Ô
€Càˆc�3ˆ;ÐrP   é   c                 ót   — g }| r3| |z  }||dz  k    r||z  }|                      d|¦  «         | |z
  |z  } | °3|S )ú-Interpolate polynomial GCD from integer GCD. rŸ   r   )Úinsert)rW   ÚxrI   rG   rH   s        rN   Ú_dup_zz_gcd_interpolaterç   k  s]   € à
€Aà
ð Ø�‰Eˆàˆq�A‰vŠ:ˆ:Ø�‰FˆAà	�Š��A‰ŒˆØ�‰U�q‰Lˆð ð ð €HrP   c                 óª  — t          | ||¦  «        }|�|S t          | ¦  «        }t          |¦  «        }t          | ||¦  «        \  }} }|dk    s|dk    r|g| |fS t          | |¦  «        }t          ||¦  «        } |dt	          ||¦  «        z  dz   ¦  «        }	t          t	          |	d|                     |	¦  «        z  ¦  «        dt	          |t          t          | |¦  «        ¦  «        z  |t          t          ||¦  «        ¦  «        z  ¦  «        z  dz   ¦  «        }
t          dt          ¦  «        D �]‘}t          | |
|¦  «        }t          ||
|¦  «        }|�r8|�r5|                     ||¦  «        }||z  }||z  }t          ||
|¦  «        }t          ||¦  «        d         }t          | ||¦  «        \  }}|s.t          |||¦  «        \  }}|st!          |||¦  «        }|||fc S t          ||
|¦  «        }t          | ||¦  «        \  }}|s.t          |||¦  «        \  }}|st!          |||¦  «        }|||fc S t          ||
|¦  «        }t          |||¦  «        \  }}|s.t          | ||¦  «        \  }}|st!          |||¦  «        }|||fc S d|
z  |                     |                     |
¦  «        ¦  «        z  d	z  }
�Œ“t#          d
¦  «        ‚)a
  
    Heuristic polynomial GCD in `Z[x]`.

    Given univariate polynomials `f` and `g` in `Z[x]`, returns
    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
    such that::

          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)

    The algorithm is purely heuristic which means it may fail to compute
    the GCD. This will be signaled by raising an exception. In this case
    you will need to switch to another GCD method.

    The algorithm computes the polynomial GCD by evaluating polynomials
    f and g at certain points and computing (fast) integer GCD of those
    evaluations. The polynomial GCD is recovered from the integer image
    by interpolation.  The final step is to verify if the result is the
    correct GCD. This gives cofactors as a side effect.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_zz_heu_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    References
    ==========

    .. [1] [Liao95]_

    Nr   rŸ   é   éc   é   rn   éB  éƒi  r’   )rº   r!   r9   r   ÚminÚmaxÚsqrtÚabsr$   ÚrangeÚHEU_GCD_MAXr0   rÔ   rç   r7   r   r   r@   )rG   rH   rI   rÖ   rÏ   rÐ   rÔ   Úf_normÚg_normr—   ræ   ÚiÚffÚggrW   rÑ   rÒ   Úcff_rM   Úcfg_s                       rN   Údup_zz_heu_gcdrû   {  s(  € õF !  A qÑ)Ô)€FàÐØˆå	�A‰Œ€BÝ	�A‰Œ€Bå˜A˜q !Ñ$Ô$�I€CˆˆAà	ˆQ‚w€w�"˜’'�'Øˆu�a˜ˆ{Ðå˜!˜QÑÔ€FÝ˜!˜QÑÔ€Fà	ˆˆ!�C�˜ÑÔÑ
 "Ñ
$Ñ%Ô%€Aå�C��2�a—f’f˜Q‘i”i‘<Ñ Ô Ø�c�&�C¥ q¨!¡¤Ñ-Ô-Ñ-Ø�C¥ q¨!¡¤Ñ-Ô-Ñ-ñ/ô /ñ /Ø12ñ3ñ	4ô 	4€Aõ �1•kÑ"Ô"ð ,1ñ ,1ˆÝ�a˜˜AÑÔˆÝ�a˜˜AÑÔˆàñ &	(�"ñ &	(Ø—’�b˜"‘”ˆAà˜‘'ˆCØ˜‘'ˆCå'¨¨1¨aÑ0Ô0ˆAÝ˜a Ñ#Ô# AÔ&ˆAå˜a  AÑ&Ô&‰GˆD�!àð )Ý! ! Q¨Ñ*Ô*‘��aàð )Ý& q¨#¨qÑ1Ô1�AØ˜d D˜=Ð(Ð(Ð(å)¨#¨q°!Ñ4Ô4ˆCå˜1˜c 1Ñ%Ô%‰DˆAˆqàð (Ý! ! Q¨Ñ*Ô*‘��aàð (Ý& q¨#¨qÑ1Ô1�AØ˜c 4˜<Ð'Ð'Ð'å)¨#¨q°!Ñ4Ô4ˆCå˜1˜c 1Ñ%Ô%‰DˆAˆqàð (Ý! ! Q¨Ñ*Ô*‘��aàð (Ý& q¨#¨qÑ1Ô1�AØ˜d C˜<Ð'Ð'Ð'à�!‰G�a—f’f˜QŸVšV A™YœYÑ'Ô'Ñ'¨5Ñ0ˆ‰å
˜YÑ
'Ô
'Ð'rP   c                 óX  — g }t          | |¦  «        s\t          | |||¦  «        }|                     d|¦  «         t          | |||¦  «        } t	          | |||¦  «        } t          | |¦  «        ¯\|                     t          ||dz   |¦  «        ¦  «        rt          ||dz   |¦  «        S |S )rä   r   rn   )r   r4   rå   r   r   Úis_negativer&   r   )rW   ræ   r‰   rI   rG   rH   s         rN   Ú_dmp_zz_gcd_interpolaterþ   å  s¸   € à
€Aå˜˜AÑÔð 'Ý˜Q  1 aÑ(Ô(ˆØ	�Š��A‰Œˆå�A�q˜!˜QÑÔˆÝ˜1˜a  AÑ&Ô&ˆõ ˜˜AÑÔð 'ð 	‡}‚}•] 1 a¨!¡e¨QÑ/Ô/Ñ0Ô0ð Ý�q˜!˜a™% Ñ#Ô#Ð#àˆrP   c                 óp  — |st          | ||¦  «        S t          | |||¦  «        }|�|S t          | |||¦  «        \  }} }t          | ||¦  «        }t          |||¦  «        } |dt	          ||¦  «        z  dz   ¦  «        }t          t	          |d|                     |¦  «        z  ¦  «        dt	          |t          t          | ||¦  «        ¦  «        z  |t          t          |||¦  «        ¦  «        z  ¦  «        z  dz   ¦  «        }	t          dt          ¦  «        D �]}
t          | |	||¦  «        }t          ||	||¦  «        }|dz
  }t          ||¦  «        �s�t          ||¦  «        �sŒt          ||||¦  «        \  }}}t          ||	||¦  «        }t          |||¦  «        d         }t!          | |||¦  «        \  }}t          ||¦  «        r>t!          ||||¦  «        \  }}t          ||¦  «        rt#          ||||¦  «        }|||fc S t          ||	||¦  «        }t!          | |||¦  «        \  }}t          ||¦  «        r>t!          ||||¦  «        \  }}t          ||¦  «        rt#          ||||¦  «        }|||fc S t          ||	||¦  «        }t!          ||||¦  «        \  }}t          ||¦  «        r>t!          | |||¦  «        \  }}t          ||¦  «        rt#          ||||¦  «        }|||fc S d|	z  |                     |                     |	¦  «        ¦  «        z  d	z  }	�Œt%          d
¦  «        ‚)a³  
    Heuristic polynomial GCD in `Z[X]`.

    Given univariate polynomials `f` and `g` in `Z[X]`, returns
    their GCD and cofactors, i.e. polynomials ``h``, ``cff`` and ``cfg``
    such that::

          h = gcd(f, g), cff = quo(f, h) and cfg = quo(g, h)

    The algorithm is purely heuristic which means it may fail to compute
    the GCD. This will be signaled by raising an exception. In this case
    you will need to switch to another GCD method.

    The algorithm computes the polynomial GCD by evaluating polynomials
    f and g at certain points and computing (fast) integer GCD of those
    evaluations. The polynomial GCD is recovered from the integer image
    by interpolation. The evaluation process reduces f and g variable by
    variable into a large integer.  The final step is to verify if the
    interpolated polynomial is the correct GCD. This gives cofactors of
    the input polynomials as a side effect.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_zz_heu_gcd(f, g)
    (x + y, x + y, x)

    References
    ==========

    .. [1] [Liao95]_

    NrŸ   ré   rê   rë   r   rn   rì   rí   r’   )rû   rÆ   r:   r   rî   rï   rð   rñ   r&   rò   ró   r1   r   Údmp_zz_heu_gcdrþ   r8   r   r   r@   )rG   rH   rS   rI   rÖ   rÔ   rô   rõ   r—   ræ   rö   r÷   rø   r‰   rW   rÑ   rÒ   rù   rM   rú   s                       rN   r   r   ö  sŠ  € ðP ð 'Ý˜a  AÑ&Ô&Ð&å   A q¨!Ñ,Ô,€FàÐØˆå" 1 a¨¨AÑ.Ô.�I€CˆˆAå˜!˜Q Ñ"Ô"€FÝ˜!˜Q Ñ"Ô"€Fà	ˆˆ!�C�˜ÑÔÑ
 "Ñ
$Ñ%Ô%€Aå�C��2�a—f’f˜Q‘i”i‘<Ñ Ô Ø�c�&�C¥¨a°°AÑ 6Ô 6Ñ7Ô7Ñ7Ø�C¥¨a°°AÑ 6Ô 6Ñ7Ô7Ñ7ñ9ô 9ñ 9Ø;<ñ=ñ	>ô 	>€Aõ �1•kÑ"Ô"ð +1ñ +1ˆÝ�a˜˜A˜qÑ!Ô!ˆÝ�a˜˜A˜qÑ!Ô!ˆà�‰Eˆå˜2˜qÑ!Ô!ñ #	(¥Z°°AÑ%6Ô%6ñ #	(Ý(¨¨R°°AÑ6Ô6‰KˆAˆs�Cå'¨¨1¨a°Ñ3Ô3ˆAÝ$ Q¨¨1Ñ-Ô-¨aÔ0ˆAå˜a  A qÑ)Ô)‰GˆD�!å˜!˜QÑÔð )Ý! ! Q¨¨1Ñ-Ô-‘��aå˜a Ñ#Ô#ð )Ý& q¨#¨q°!Ñ4Ô4�AØ˜d D˜=Ð(Ð(Ð(å)¨#¨q°!°QÑ7Ô7ˆCå˜1˜c 1 aÑ(Ô(‰DˆAˆqå˜!˜QÑÔð (Ý! ! Q¨¨1Ñ-Ô-‘��aå˜a Ñ#Ô#ð (Ý& q¨#¨q°!Ñ4Ô4�AØ˜c 4˜<Ð'Ð'Ð'å)¨#¨q°!°QÑ7Ô7ˆCå˜1˜c 1 aÑ(Ô(‰DˆAˆqå˜!˜QÑÔð (Ý! ! Q¨¨1Ñ-Ô-‘��aå˜a Ñ#Ô#ð (Ý& q¨#¨q°!Ñ4Ô4�AØ˜d C˜<Ð'Ð'Ð'à�!‰G�a—f’f˜QŸVšV A™YœYÑ'Ô'Ñ'¨5Ñ0ˆ‰å
˜YÑ
'Ô
'Ð'rP   c                 óV  — t          | ||¦  «        }|�|S |                     ¦   «         }t          | ||¦  «        \  }} t          |||¦  «        \  }}t          | ||¦  «        } t          |||¦  «        }t	          | ||¦  «        \  }}}	t          |||¦  «        }t          ||¦  «        }
t          ||¦  «        }t          |||¦  «        }t          |	||¦  «        }	t          ||                     |
|¦  «        |¦  «        }t          |	|                     |
|¦  «        |¦  «        }	|||	fS )a‹  
    Heuristic polynomial GCD in `Q[x]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
    >>> g = QQ(1,2)*x**2 + x

    >>> R.dup_qq_heu_gcd(f, g)
    (x + 2, 1/2*x + 3/4, 1/2*x)

    )	r½   r§   r,   r)   rû   r$   r5   r   ro   )rG   rH   r©   rÖ   rª   r«   r¬   rW   rÑ   rÒ   ru   s              rN   Údup_qq_heu_gcdr  a  s%  € õ( !  A rÑ*Ô*€FàÐØˆà	�Š‰Œ€Bå˜Q  BÑ'Ô'�E€BˆÝ˜Q  BÑ'Ô'�E€Bˆå�A�r˜2ÑÔ€AÝ�A�r˜2ÑÔ€Aå   A rÑ*Ô*�K€A€sˆCå�A�r˜2ÑÔ€Aåˆq�"‰Œ€AÝ�!�RÑÔ€Aå
�c˜2˜rÑ
"Ô
"€CÝ
�c˜2˜rÑ
"Ô
"€Cå
˜˜bŸfšf Q¨™mœm¨RÑ
0Ô
0€CÝ
˜˜bŸfšf Q¨™mœm¨RÑ
0Ô
0€Càˆc�3ˆ;ÐrP   c                 óp  — t          | |||¦  «        }|�|S |                     ¦   «         }t          | |||¦  «        \  }} t          ||||¦  «        \  }}t          | |||¦  «        } t          ||||¦  «        }t	          | |||¦  «        \  }}	}
t          ||||¦  «        }t          |||¦  «        }t          |||¦  «        }t          |	|||¦  «        }	t          |
|||¦  «        }
t          |	|                     ||¦  «        ||¦  «        }	t          |
|                     ||¦  «        ||¦  «        }
||	|
fS )a�  
    Heuristic polynomial GCD in `Q[X]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y, = ring("x,y", QQ)

    >>> f = QQ(1,4)*x**2 + x*y + y**2
    >>> g = QQ(1,2)*x**2 + x*y

    >>> R.dmp_qq_heu_gcd(f, g)
    (x + 2*y, 1/4*x + 1/2*y, 1/2*x)

    )	rÈ   r§   r-   r*   r   r&   r6   r   ro   )rG   rH   rS   r©   rÖ   rª   r«   r¬   rW   rÑ   rÒ   ru   s               rN   Údmp_qq_heu_gcdr  ’  sA  € õ( !  A q¨"Ñ-Ô-€FàÐØˆà	�Š‰Œ€Bå˜Q  2 rÑ*Ô*�E€BˆÝ˜Q  2 rÑ*Ô*�E€Bˆå�A�q˜"˜bÑ!Ô!€AÝ�A�q˜"˜bÑ!Ô!€Aå   A q¨"Ñ-Ô-�K€A€sˆCå�A�q˜"˜bÑ!Ô!€Aå�a˜˜BÑÔ€AÝ˜˜A˜rÑ"Ô"€Aå
�c˜1˜b "Ñ
%Ô
%€CÝ
�c˜1˜b "Ñ
%Ô
%€Cå
˜˜bŸfšf Q¨™mœm¨Q°Ñ
3Ô
3€CÝ
˜˜bŸfšf Q¨™mœm¨Q°Ñ
3Ô
3€Càˆc�3ˆ;ÐrP   c                 ó�  — |j         s|j        r 	 |                     ¦   «         }n# t          $ r |j        g| |fcY S w xY wt          | ||¦  «        } t          |||¦  «        }t          | ||¦  «        \  }}}t          |||¦  «        }t          |||¦  «        }t          |||¦  «        }|||fS |j        rI|j        r1t          d¦  «        r"	 t          | ||¦  «        S # t          $ r Y nw xY wt          | ||¦  «        S |j        r1t          d¦  «        r"	 t          | ||¦  «        S # t          $ r Y nw xY wt          | ||¦  «        S )ag  
    Computes polynomial GCD and cofactors of `f` and `g` in `K[x]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_inner_gcd(x**2 - 1, x**2 - 3*x + 2)
    (x - 1, x + 1, x - 2)

    ÚUSE_HEU_GCD)Úis_RRÚis_CCÚ	get_exactrC   rF   r)   Údup_inner_gcdrE   r°   r>   r  r@   rÛ   r±   rû   rÙ   )rG   rH   rI   ÚexactrW   rÑ   rÒ   s          rN   r
  r
  Ã  s¨  € ð: 	„wð '�!”'ð 'ð	!Ø—K’K‘M”MˆEˆEøÝð 	!ð 	!ð 	!Ø”E�7˜A˜q�=Ð Ð Ð ð	!øøøõ ˜˜1˜eÑ$Ô$ˆÝ˜˜1˜eÑ$Ô$ˆå# A q¨%Ñ0Ô0‰ˆˆ3�å˜˜5 !Ñ$Ô$ˆÝ˜#˜u aÑ(Ô(ˆÝ˜#˜u aÑ(Ô(ˆà�#�sˆ{ÐØ	
Œð 'ØŒ7ð 	•u˜]Ñ+Ô+ð 	ðÝ% a¨¨AÑ.Ô.Ð.øÝ%ð ð ð Ø�ðøøøõ ˜a  AÑ&Ô&Ð&àŒ7ð 	•u˜]Ñ+Ô+ð 	ðÝ% a¨¨AÑ.Ô.Ð.øÝ%ð ð ð Ø�ðøøøõ ˜a  AÑ&Ô&Ð&s0   �% ¥=¼=ÃC Ã
C+Ã*C+ÄD' Ä'
D4Ä3D4c                 ó¦  — |j         s®	 |                     ¦   «         }n## t          $ r t          ||¦  «        | |fcY S w xY wt	          | |||¦  «        } t	          ||||¦  «        }t          | |||¦  «        \  }}}t	          ||||¦  «        }t	          ||||¦  «        }t	          ||||¦  «        }|||fS |j        rK|j        r2t          d¦  «        r#	 t          | |||¦  «        S # t          $ r Y nw xY wt          | |||¦  «        S |j        r2t          d¦  «        r#	 t          | |||¦  «        S # t          $ r Y nw xY wt          | |||¦  «        S )z'Helper function for `dmp_inner_gcd()`. r  )Úis_Exactr	  rC   r   r*   Ú_dmp_inner_gcdrE   r°   r>   r  r@   rá   r±   r   rÞ   )rG   rH   rS   rI   r  rW   rÑ   rÒ   s           rN   r  r    s¶  € àŒ:ð *ð	'Ø—K’K‘M”MˆEˆEøÝð 	'ð 	'ð 	'Ý˜1˜a‘=”= ! QÐ&Ð&Ð&Ð&ð	'øøøõ ˜˜1˜a Ñ'Ô'ˆÝ˜˜1˜a Ñ'Ô'ˆå$ Q¨¨1¨eÑ4Ô4‰ˆˆ3�å˜˜1˜e QÑ'Ô'ˆÝ˜#˜q %¨Ñ+Ô+ˆÝ˜#˜q %¨Ñ+Ô+ˆà�#�sˆ{ÐØ	
Œð *ØŒ7ð 	•u˜]Ñ+Ô+ð 	ðÝ% a¨¨A¨qÑ1Ô1Ð1øÝ%ð ð ð Ø�ðøøøõ ˜a  A qÑ)Ô)Ð)àŒ7ð 	•u˜]Ñ+Ô+ð 	ðÝ% a¨¨A¨qÑ1Ô1Ð1øÝ%ð ð ð Ø�ðøøøõ ˜a  A qÑ)Ô)Ð)s0   ‰ ž>½>ÃC& Ã&
C3Ã2C3ÄD1 Ä1
D>Ä=D>c                 óð   — |st          | ||¦  «        S t          | |f||¦  «        \  }\  } }t          | |||¦  «        \  }}}t          ||||¦  «        t          ||||¦  «        t          ||||¦  «        fS )aŒ  
    Computes polynomial GCD and cofactors of `f` and `g` in `K[X]`.

    Returns ``(h, cff, cfg)`` such that ``a = gcd(f, g)``,
    ``cff = quo(f, h)``, and ``cfg = quo(g, h)``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_inner_gcd(f, g)
    (x + y, x + y, x)

    )r
  r'   r  r(   )rG   rH   rS   rI   ÚJrW   rÑ   rÒ   s           rN   Údmp_inner_gcdr  &  s‘   € ð( ð &Ý˜Q  1Ñ%Ô%Ð%å! 1 a &¨!¨QÑ/Ô/�I€A�vˆˆ1Ý   A q¨!Ñ,Ô,�K€A€sˆCå˜˜1˜a Ñ#Ô#Ý˜˜Q  1Ñ%Ô%Ý˜˜Q  1Ñ%Ô%ð'ð 'rP   c                 ó0   — t          | ||¦  «        d         S )zÕ
    Computes polynomial GCD of `f` and `g` in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_gcd(x**2 - 1, x**2 - 3*x + 2)
    x - 1

    r   )r
  rz   s      rN   Údup_gcdr  E  s   € õ ˜˜A˜qÑ!Ô! !Ô$Ð$rP   c                 ó2   — t          | |||¦  «        d         S )zþ
    Computes polynomial GCD of `f` and `g` in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_gcd(f, g)
    x + y

    r   )r  rR   s       rN   rÎ   rÎ   V  s   € õ" ˜˜A˜q !Ñ$Ô$ QÔ'Ð'rP   c                 ól  — | r|st          d¦  «        S t          | |¦  «        \  }} t          ||¦  «        \  }}|                     ||¦  «        }t          t	          | ||¦  «        t          | ||¦  «        |¦  «        }|                     t          ||¦  «        ¦  «        }t          |||z  |¦  «        S )zå
    Computes polynomial LCM over a ring in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_rr_lcm(x**2 - 1, x**2 - 3*x + 2)
    x**3 - 2*x**2 - x + 2

    r   )	r   r7   Úlcmr   r   r  rÕ   r$   r   )rG   rH   rI   r×   rØ   ru   rW   rS   s           rN   Ú
dup_rr_lcmr  j  s·   € ð ð �Að Ý˜‰{Œ{Ðå˜!˜QÑÔ�E€BˆÝ˜!˜QÑÔ�E€Bˆà	�Šˆb�"‰Œ€Aå•˜˜1˜aÑ Ô Ý˜˜1˜aÑ Ô  !ñ	%ô 	%€Að 	
×Ò�  1™œÑ&Ô&€Aå˜!˜Q˜q™S !Ñ$Ô$Ð$rP   c                 ó€   — t          t          | ||¦  «        t          | ||¦  «        |¦  «        }t          ||¦  «        S )a  
    Computes polynomial LCM over a field in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = QQ(1,2)*x**2 + QQ(7,4)*x + QQ(3,2)
    >>> g = QQ(1,2)*x**2 + x

    >>> R.dup_ff_lcm(f, g)
    x**3 + 7/2*x**2 + 3*x

    )r   r   r  r5   )rG   rH   rI   rW   s       rN   Ú
dup_ff_lcmr  ˆ  sB   € õ" 	•˜˜1˜aÑ Ô Ý˜˜1˜aÑ Ô  !ñ	%ô 	%€Aõ �Q˜‰?Œ?ÐrP   c                 óT   — |j         rt          | ||¦  «        S t          | ||¦  «        S )zå
    Computes polynomial LCM of `f` and `g` in `K[x]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_lcm(x**2 - 1, x**2 - 3*x + 2)
    x**3 - 2*x**2 - x + 2

    )rE   r  r  rz   s      rN   Údup_lcmr  Ÿ  s2   € ð 	„zð #Ý˜!˜Q Ñ"Ô"Ð"å˜!˜Q Ñ"Ô"Ð"rP   c           	      ó  — t          | ||¦  «        \  }} t          |||¦  «        \  }}|                     ||¦  «        }t          t          | |||¦  «        t	          | |||¦  «        ||¦  «        }t          ||||¦  «        S )a  
    Computes polynomial LCM over a ring in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_rr_lcm(f, g)
    x**3 + 2*x**2*y + x*y**2

    )r8   r  r   r	   rÎ   r   )rG   rH   rS   rI   r×   rØ   ru   rW   s           rN   Ú
dmp_rr_lcmr  ³  s‰   € õ" !  A qÑ)Ô)�E€BˆÝ   A qÑ)Ô)�E€Bˆà	�Šˆb�"‰Œ€Aå•˜˜1˜a Ñ#Ô#Ý˜˜1˜a Ñ#Ô# Q¨ñ	+ô 	+€Aõ ˜!˜Q  1Ñ%Ô%Ð%rP   c           	      óˆ   — t          t          | |||¦  «        t          | |||¦  «        ||¦  «        }t          |||¦  «        S )a"  
    Computes polynomial LCM over a field in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y, = ring("x,y", QQ)

    >>> f = QQ(1,4)*x**2 + x*y + y**2
    >>> g = QQ(1,2)*x**2 + x*y

    >>> R.dmp_ff_lcm(f, g)
    x**3 + 4*x**2*y + 4*x*y**2

    )r   r	   rÎ   r6   )rG   rH   rS   rI   rW   s        rN   Ú
dmp_ff_lcmr  Ï  sL   € õ" 	•˜˜1˜a Ñ#Ô#Ý˜˜1˜a Ñ#Ô# Q¨ñ	+ô 	+€Aõ ˜A˜q !Ñ$Ô$Ð$rP   c                 ó~   — |st          | ||¦  «        S |j        rt          | |||¦  «        S t          | |||¦  «        S )a  
    Computes polynomial LCM of `f` and `g` in `K[X]`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> f = x**2 + 2*x*y + y**2
    >>> g = x**2 + x*y

    >>> R.dmp_lcm(f, g)
    x**3 + 2*x**2*y + x*y**2

    )r  rE   r  r  rR   s       rN   Údmp_lcmr!  æ  sP   € ð" ð  Ý�q˜!˜QÑÔÐà„zð &Ý˜!˜Q  1Ñ%Ô%Ð%å˜!˜Q  1Ñ%Ô%Ð%rP   c                 ó"  — t          | |¦  «        |dz
  }}t          | |¦  «        r|S | dd…         D ]'}t          ||||¦  «        }t          |||¦  «        r nŒ(|                     t          |||¦  «        ¦  «        rt          |||¦  «        S |S )zÖ
    Returns GCD of multivariate coefficients.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> R.dmp_content(2*x*y + 6*x + 4*y + 12)
    2*y + 6

    rn   N)r%   r   rÎ   r   rý   r&   r   )rG   rS   rI   Úcontr‰   ru   s         rN   rÍ   rÍ      s±   € õ �Q˜‰lŒl˜A ™Eˆ!€Då�!�QÑÔð ØˆàˆqˆrˆrŒUð ð ˆÝ�t˜Q  1Ñ%Ô%ˆå�T˜1˜aÑ Ô ð 	ØˆEð	ð 	‡}‚}•] 4¨¨AÑ.Ô.Ñ/Ô/ð Ý�t˜Q Ñ"Ô"Ð"àˆrP   c                 ó¤   ‡‡‡— t          | |‰¦  «        |dz
  cŠŠt          | |¦  «        st          ‰‰‰¦  «        r‰| fS ‰ˆˆˆfd„| D ¦   «         fS )zð
    Returns multivariate content and a primitive polynomial.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y, = ring("x,y", ZZ)

    >>> R.dmp_primitive(2*x*y + 6*x + 4*y + 12)
    (2*y + 6, x + 2)

    rn   c                 ó4   •— g | ]}t          |‰‰‰¦  «        ‘ŒS r…   r†   )r‡   ru   rI   r#  r‰   s     €€€rN   rŠ   z!dmp_primitive.<locals>.<listcomp>2  s'   ø€ Ð:Ð:Ð:°!•w˜q $¨¨1Ñ-Ô-Ð:Ð:Ð:rP   )rÍ   r   r   )rG   rS   rI   r#  r‰   s     `@@rN   rÝ   rÝ     sv   øøø€ õ ˜!˜Q Ñ"Ô" A¨¡E€G€Dˆ!å�!�QÑÔð ;�9 T¨1¨aÑ0Ô0ð ;Ø�QˆwˆàÐ:Ð:Ð:Ð:Ð:Ð:°qÐ:Ñ:Ô:Ð:Ð:rP   Tc                 ó*   — t          | |d||¬¦  «        S )zç
    Cancel common factors in a rational function `f/g`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_cancel(2*x**2 - 2, x**2 - 2*x + 1)
    (2*x + 2, x - 1)

    r   )Úinclude)Ú
dmp_cancel)rG   rH   rI   r'  s       rN   Ú
dup_cancelr)  5  s   € õ �a˜˜A˜q¨'Ð2Ñ2Ô2Ð2rP   c                 ó  — d}|j         rL|j        rE||                     ¦   «         }}t          | |||d¬¦  «        \  }} t          ||||d¬¦  «        \  }}n|j        |j        }}t          | |||¦  «        \  }}	}
|�@|                     ||¦  «        \  }}}t          |	|||¦  «        }	t          |
|||¦  «        }
|}|                     t          |	||¦  «        ¦  «        }|                     t          |
||¦  «        ¦  «        }|r%|r#t          |	||¦  «        t          |
||¦  «        }
}	n-|r| t          |	||¦  «        }	}n|r| t          |
||¦  «        }
}|s|||	|
fS t          |	|||¦  «        }	t          |
|||¦  «        }
|	|
fS )zë
    Cancel common factors in a rational function `f/g`.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> R.dmp_cancel(2*x**2 - 2, x**2 - 2*x + 1)
    (2*x + 2, x - 1)

    NT)r¨   )rE   Úhas_assoc_Ringr§   r-   rF   r  Ú	cofactorsr*   rý   r&   r   r   )rG   rH   rS   rI   r'  r©   ÚcqÚcpri   r‹   rL   Úp_negÚq_negs                rN   r(  r(  F  sÈ  € ð 
€Bà„zð �aÔ&ð Ø�1—:’:‘<”<ˆAˆå   A r¨1°dÐ;Ñ;Ô;‰ˆˆAÝ   A r¨1°dÐ;Ñ;Ô;‰ˆˆAˆAà”˜œˆBˆå˜A˜q ! QÑ'Ô'�G€A€qˆ!à	€~Ø—K’K  BÑ'Ô'‰	ˆˆ2ˆrå˜˜1˜a Ñ$Ô$ˆÝ˜˜1˜a Ñ$Ô$ˆàˆà�MŠM�-¨¨1¨aÑ0Ô0Ñ1Ô1€EØ�MŠM�-¨¨1¨aÑ0Ô0Ñ1Ô1€Eàð &�ð &Ý�q˜!˜QÑÔ¥¨¨A¨qÑ!1Ô!1ˆ1ˆˆØ	ð &Ø�•W˜Q  1Ñ%Ô%ˆAˆˆØ	ð &Ø�•W˜Q  1Ñ%Ô%ˆAˆàð Ø�2�q˜!ˆ|Ðå�q˜"˜a Ñ#Ô#€AÝ�q˜"˜a Ñ#Ô#€Aàˆaˆ4€KrP   N)F)T)~Ú__doc__Úsympy.polys.densearithr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Úsympy.polys.densebasicr   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   Úsympy.polys.densetoolsr,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   Úsympy.polys.galoistoolsr<   r=   Úsympy.polys.polyconfigr>   Úsympy.polys.polyerrorsr?   r@   rA   rB   rC   rO   rT   rZ   r\   r^   r`   rd   rf   rj   rl   rx   r{   r   r‚   rŒ   rŽ   r�   r“   r�   r¥   r­   r²   r´   r¶   rº   r½   rÆ   rÈ   rÂ   rÙ   rÛ   rÞ   rá   ró   rç   rû   rþ   r   r  r  r
  r  r  r  rÎ   r  r  r  r  r  r!  rÍ   rÝ   r)  r(  r…   rP   rN   ú<module>r8     sh  ðØ KÐ Kð ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð  ð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð 	ð%ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ð %ðð ð ð ð ð ð ð à (Ð (Ð (Ð (Ð (Ð (ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð  ð  ðF0ð 0ð 0ð"ð ð ð60ð 0ð 0ð",ð ,ð ,ð>0ð 0ð 0ð"%ð %ð %ðP0ð 0ð 0ð"%ð %ð %ðP0ð 0ð 0ð"Mð Mð Mð`/ð /ð /ð"ð ð ð2)ð )ð )ð )ð&Mð Mð Mð`2ð 2ð 2ð.%ð %ð %ðPFð Fð FðR2ð 2ð 2ð
:ð :ð :ðz$+ð $+ð $+ðN,ð ,ð ,ð ,ðB ð  ð  ð6#ð #ð #ð>ð ð ð$	ð 	ð 	ðð ð ð4ð ð ð*ð ð ð8%ð %ð %ðPð ð ð>-ð -ð -ð`)ð )ð )ðV €ðð ð ð g(ð g(ð g(ðTð ð ð"h(ð h(ð h(ðV.ð .ð .ðb.ð .ð .ðb<'ð <'ð <'ð~!*ð !*ð !*ðH'ð 'ð 'ð>%ð %ð %ð"(ð (ð (ð(%ð %ð %ð<ð ð ð.#ð #ð #ð(&ð &ð &ð8%ð %ð %ð.&ð &ð &ð4ð ð ð>;ð ;ð ;ð,3ð 3ð 3ð 3ð"2ð 2ð 2ð 2ð 2ð 2rP   