Ë
    O/æj°j  ã                   óø  — 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 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, ddl-m.Z. ddl/m0Z1m2Z3 d„ Z4d„ Z5d	„ Z6d
„ Z7d„ Z8d„ Z9d„ Z:d„ Z;d„ Z<d„ Z=d„ Z>d„ Z?d„ Z@d„ ZAd„ ZBd„ ZCd„ ZDd„ ZEd„ ZFd„ ZGd„ ZHd„ ZId„ ZJd„ ZKd„ ZLd „ ZMd!„ ZNd"„ ZOd#„ ZPd$„ ZQd%„ ZRd&„ ZSd'„ ZTd(„ ZUd)„ ZVd*„ ZWd+„ ZXd,„ ZYd-„ ZZd.„ Z[d/„ Z\d6d1„Z]d2„ Z^d6d3„Z_d4„ Z`d5„ Zay0)7zHAdvanced tools for dense recursive polynomials in ``K[x]`` or ``K[X]``. é    )Údup_add_termÚdmp_add_termÚ
dup_lshiftÚdup_addÚdmp_addÚdup_subÚdmp_subÚdup_mulÚdmp_mulÚdup_sqrÚdup_divÚdup_remÚdmp_remÚ
dmp_expandÚdup_mul_groundÚdmp_mul_groundÚdup_quo_groundÚdmp_quo_groundÚdup_exquo_groundÚdmp_exquo_ground)Ú	dup_stripÚ	dmp_stripÚdup_convertÚdmp_convertÚ
dup_degreeÚ
dmp_degreeÚdmp_to_dictÚdmp_from_dictÚdup_LCÚdmp_LCÚdmp_ground_LCÚdup_TCÚdmp_TCÚdmp_zeroÚ
dmp_groundÚ
dmp_zero_pÚdup_to_raw_dictÚdup_from_raw_dictÚ	dmp_zeros)ÚMultivariatePolynomialErrorÚDomainError)Ú
variations)ÚceilÚlog2c           
      ó  — |dk  s| s| S |j                   g|z  }t        t        | «      «      D ]N  \  }}|dz   }t        d|«      D ]  }|||z   dz   z  }Œ |j	                  d|j                  | ||«      «      «       ŒP |S )a  
    Computes the indefinite integral of ``f`` in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_integrate(x**2 + 2*x, 1)
    1/3*x**3 + x**2
    >>> R.dup_integrate(x**2 + 2*x, 2)
    1/12*x**4 + 1/3*x**3

    r   é   )ÚzeroÚ	enumerateÚreversedÚrangeÚinsertÚexquo)ÚfÚmÚKÚgÚiÚcÚnÚjs           úY/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/sympy/polys/densetools.pyÚdup_integrater@   '   s’   € ð  	ˆA‚v‘QØˆà	
�‰ˆ�‰
€Aäœ( 1›+Ó&ò &‰ˆˆ1Ø�‰Eˆä�q˜!“ò 	ˆAØ��Q‘˜‘‰N‰Að	ð 	
�‰��A—G‘G˜A™q ›tÓ$Õ%ð&ð €Hó    c           
      ó6  — |st        | ||«      S |dk  st        | |«      r| S t        ||dz
  |«      |dz
  }}t        t	        | «      «      D ]J  \  }}|dz   }t        d|«      D ]  }	|||	z   dz   z  }Œ |j                  dt        | ||«      ||«      «       ŒL |S )a&  
    Computes the indefinite integral of ``f`` in ``x_0`` in ``K[X]``.

    Examples
    ========

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

    >>> R.dmp_integrate(x + 2*y, 1)
    1/2*x**2 + 2*x*y
    >>> R.dmp_integrate(x + 2*y, 2)
    1/6*x**3 + x**2*y

    r   r0   )r@   r&   r)   r2   r3   r4   r5   r   )
r7   r8   Úur9   r:   Úvr;   r<   r=   r>   s
             r?   Údmp_integraterE   G   s¶   € ñ  Ü˜Q  1Ó%Ð%àˆA‚v”˜A˜qÔ!Øˆä�Q˜˜A™˜qÓ! 1 q¡5€q€Aäœ( 1›+Ó&ò 3‰ˆˆ1Ø�‰Eˆä�q˜!“ò 	ˆAØ��Q‘˜‘‰N‰Að	ð 	
�‰�”N 1¡a¨£d¨A¨qÓ1Õ2ð3ð €HrA   c                 ó–   — ||k(  rt        | |||«      S |dz
  |dz   }}t        | D �cg c]  }t        ||||||«      ‘Œ c}|«      S c c}w )z.Recursive helper for :func:`dmp_integrate_in`.r0   )rE   r   Ú_rec_integrate_in©r:   r8   rD   r;   r>   r9   Úwr<   s           r?   rG   rG   j   sV   € àˆA‚vÜ˜Q  1 aÓ(Ð(àˆq‰5�!�a‘%€q€AäÀAÖG¸qÔ(¨¨A¨q°!°Q¸Õ:ÒGÈÓKÐKùÒGó   §Ac                 óV   — |dk  s||kD  rt        d||fz  «      ‚t        | ||d||«      S )a+  
    Computes the indefinite integral of ``f`` in ``x_j`` in ``K[X]``.

    Examples
    ========

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

    >>> R.dmp_integrate_in(x + 2*y, 1, 0)
    1/2*x**2 + 2*x*y
    >>> R.dmp_integrate_in(x + 2*y, 1, 1)
    x*y + y**2

    r   z(0 <= j <= u expected, got u = %d, j = %d)Ú
IndexErrorrG   ©r7   r8   r>   rC   r9   s        r?   Údmp_integrate_inrN   t   s;   € ð  	ˆ1‚u��A’ÜÐCÀqÈ!ÀfÑLÓMÐMä˜Q  1 a¨¨AÓ.Ð.rA   c                 óT  — |dk  r| S t        | «      }||k  rg S g }|dk(  r5| d|  D ]!  }|j                   ||«      |z  «       |dz  }Œ# t        |«      S | d|  D ]@  }|}t        |dz
  ||z
  d«      D ]  }||z  }Œ	 |j                   ||«      |z  «       |dz  }ŒB t        |«      S )a#  
    ``m``-th order derivative of a polynomial in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_diff(x**3 + 2*x**2 + 3*x + 4, 1)
    3*x**2 + 4*x + 3
    >>> R.dup_diff(x**3 + 2*x**2 + 3*x + 4, 2)
    6*x + 4

    r   r0   Néÿÿÿÿ)r   Úappendr4   r   )r7   r8   r9   r=   ÚderivÚcoeffÚkr;   s           r?   Údup_diffrU   Š   så   € ð  	ˆA‚vØˆä�1‹€Aàˆ1‚uØˆ	à€EàˆA‚vØ�s˜˜�Vò 	ˆEØ�L‰L™˜1›˜e™Ô$Ø�‰F‰Að	ô �UÓÐð �s˜˜�Vò 	ˆEØˆAä˜1˜q™5 ! a¡%¨Ó,ò �Ø�Q‘‘ðð �L‰L™˜1›˜e™Ô$Ø�‰F‰Að	ô �UÓÐrA   c           	      ó¢  — |st        | ||«      S |dk  r| S t        | |«      }||k  rt        |«      S g |dz
  }}|dk(  r4| d|  D ]*  }|j                  t	        | ||«      ||«      «       |dz  }Œ, nR| d|  D ]I  }|}t        |dz
  ||z
  d«      D ]  }	||	z  }Œ	 |j                  t	        | ||«      ||«      «       |dz  }ŒK t        ||«      S )a3  
    ``m``-th order derivative in ``x_0`` of a polynomial in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_diff(f, 1)
    y**2 + 2*y + 3
    >>> R.dmp_diff(f, 2)
    0

    r   r0   NrP   )rU   r   r$   rQ   r   r4   r   )
r7   r8   rC   r9   r=   rR   rD   rS   rT   r;   s
             r?   Údmp_diffrW   µ   s
  € ñ$ Ü˜˜1˜aÓ Ð ØˆA‚vØˆä�1�aÓ€Aàˆ1‚uÜ˜‹{Ðà�1�q‘5ˆ1€EàˆA‚vØ�s˜˜�Vò 	ˆEØ�L‰Lœ¨©q°«t°Q¸Ó:Ô;Ø�‰F‰Añ	ð �s˜˜�Vò 	ˆEØˆAä˜1˜q™5 ! a¡%¨Ó,ò �Ø�Q‘‘ðð �L‰Lœ¨©q°«t°Q¸Ó:Ô;Ø�‰F‰Að	ô �U˜AÓÐrA   c                 ó–   — ||k(  rt        | |||«      S |dz
  |dz   }}t        | D �cg c]  }t        ||||||«      ‘Œ c}|«      S c c}w )z)Recursive helper for :func:`dmp_diff_in`.r0   )rW   r   Ú_rec_diff_inrH   s           r?   rY   rY   ä   óU   € àˆA‚vÜ˜˜1˜a Ó#Ð#àˆq‰5�!�a‘%€q€Aä¸qÖB¸!”| A q¨!¨Q°°1Õ5ÒBÀAÓFÐFùÒBrJ   c                 óX   — |dk  s||kD  rt        d|›d|›�«      ‚t        | ||d||«      S )aS  
    ``m``-th order derivative in ``x_j`` of a polynomial in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_diff_in(f, 1, 0)
    y**2 + 2*y + 3
    >>> R.dmp_diff_in(f, 1, 1)
    2*x*y + 2*x + 4*y + 3

    r   ú
0 <= j <= ú expected, got )rL   rY   rM   s        r?   Údmp_diff_inr^   î   ó6   € ð$ 	ˆ1‚u��A’ÝºA¹qÐAÓBÐBä˜˜1˜a  A qÓ)Ð)rA   c                 óz   — |s|j                  t        | |«      «      S |j                  }| D ]  }||z  }||z  }Œ |S )zÞ
    Evaluate a polynomial at ``x = a`` in ``K[x]`` using Horner scheme.

    Examples
    ========

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

    >>> R.dup_eval(x**2 + 2*x + 3, 2)
    11

    )Úconvertr"   r1   )r7   Úar9   Úresultr<   s        r?   Údup_evalrd     sM   € ñ Ø�y‰yœ  1›Ó&Ð&à�V‰V€Fàò ˆØ�!‰ˆØ�!‰‰ðð €MrA   c                 ó®   — |st        | ||«      S |st        | |«      S t        | |«      |dz
  }}| dd D ]  }t        ||||«      }t	        ||||«      }Œ  |S )zò
    Evaluate a polynomial at ``x_0 = a`` in ``K[X]`` using the Horner scheme.

    Examples
    ========

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

    >>> R.dmp_eval(2*x*y + 3*x + y + 2, 2)
    5*y + 8

    r0   N)rd   r#   r    r   r   )r7   rb   rC   r9   rc   rD   rS   s          r?   Údmp_evalrf      st   € ñ Ü˜˜1˜aÓ Ð áÜ�a˜‹|Ðä�q˜!“˜a !™eˆA€Fà�1�2�ò .ˆÜ ¨¨1¨aÓ0ˆÜ˜ ¨¨1Ó-‰ð.ð €MrA   c                 ó–   — ||k(  rt        | |||«      S |dz
  |dz   }}t        | D �cg c]  }t        ||||||«      ‘Œ c}|«      S c c}w )z)Recursive helper for :func:`dmp_eval_in`.r0   )rf   r   Ú_rec_eval_in)r:   rb   rD   r;   r>   r9   r<   s          r?   rh   rh   =  rZ   rJ   c                 óX   — |dk  s||kD  rt        d|›d|›�«      ‚t        | ||d||«      S )a2  
    Evaluate a polynomial at ``x_j = a`` in ``K[X]`` using the Horner scheme.

    Examples
    ========

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

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

    >>> R.dmp_eval_in(f, 2, 0)
    5*y + 8
    >>> R.dmp_eval_in(f, 2, 1)
    7*x + 4

    r   r\   r]   )rL   rh   )r7   rb   r>   rC   r9   s        r?   Údmp_eval_inrj   G  r_   rA   c           
      óÎ   — ||k(  rt        | |d   |«      S | D �cg c]  }t        ||dz   |||«      ‘Œ }}||t        |«      z
  dz   k  r|S t        ||| |z   dz
     |«      S c c}w )z+Recursive helper for :func:`dmp_eval_tail`.rP   r0   )rd   Ú_rec_eval_tailÚlen)r:   r;   ÚArC   r9   r<   Úhs          r?   rl   rl   _  s{   € àˆA‚vÜ˜˜1˜R™5 !Ó$Ð$à9:Ö<°AŒn˜Q  A¡ q¨!¨QÕ/Ð<ˆÐ<àˆq”3�q“6‰z˜A‰~ÒØˆHä˜A˜q !  a¡¨!¡™}¨aÓ0Ð0ùò =s   šA"c                 óÄ   — |s| S t        | |«      rt        |t        |«      z
  «      S t        | d|||«      }|t        |«      dz
  k(  r|S t	        ||t        |«      z
  «      S )a!  
    Evaluate a polynomial at ``x_j = a_j, ...`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_eval_tail(f, [2])
    7*x + 4
    >>> R.dmp_eval_tail(f, [2, 2])
    18

    r   r0   )r&   r$   rm   rl   r   )r7   rn   rC   r9   Úes        r?   Údmp_eval_tailrr   l  sd   € ñ$ Øˆä�!�QÔÜ˜œC ›F™
Ó#Ð#ä�q˜!˜Q  1Ó%€AàŒC�‹F�Q‰J‚Øˆä˜˜A¤ A£™JÓ'Ð'rA   c                 ó°   — ||k(  rt        t        | |||«      |||«      S |dz
  |dz   }}t        | D �cg c]  }t        |||||||«      ‘Œ c}|«      S c c}w )z+Recursive helper for :func:`dmp_diff_eval`.r0   )rf   rW   r   Ú_rec_diff_eval)r:   r8   rb   rD   r;   r>   r9   r<   s           r?   rt   rt   Œ  sb   € àˆA‚vÜœ  A q¨!Ó,¨a°°AÓ6Ð6àˆq‰5�!�a‘%€q€AäÀAÖG¸q”~ a¨¨A¨q°!°Q¸Õ:ÒGÈÓKÐKùÒGs   ³Ac           	      óŽ   — ||kD  rt        d|›d|›d|›�«      ‚|st        t        | |||«      |||«      S t        | |||d||«      S )a]  
    Differentiate and evaluate a polynomial in ``x_j`` at ``a`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_diff_eval_in(f, 1, 2, 0)
    y**2 + 2*y + 3
    >>> R.dmp_diff_eval_in(f, 1, 2, 1)
    6*x + 11

    ú-z <= j < r]   r   )rL   rf   rW   rt   )r7   r8   rb   r>   rC   r9   s         r?   Údmp_diff_eval_inrw   –  sS   € ð$ 	ˆ1‚uÝºQÂÁ1ÐEÓFÐFÙÜœ  A q¨!Ó,¨a°°AÓ6Ð6ä˜!˜Q  1 a¨¨AÓ.Ð.rA   c                 ó|  — |j                   rGg }| D ]5  }||z  }||dz  kD  r|j                  ||z
  «       Œ%|j                  |«       Œ7 t	        |«      S |j                  r7t        |«      }| D �cg c]  } |t        |«      |z  «      ‘Œ }}t	        |«      S | D �cg c]  }||z  ‘Œ	 }}t	        |«      S c c}w c c}w )zô
    Reduce a ``K[x]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

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

    >>> R.dup_trunc(2*x**3 + 3*x**2 + 5*x + 7, ZZ(3))
    -x**3 - x + 1

    é   )Úis_ZZrQ   Úis_FiniteFieldÚintr   )r7   Úpr9   r:   r<   Úpis         r?   Ú	dup_truncr   °  sÃ   € ð 	‡w‚wØˆàò 	ˆAØ�A‘ˆAà�1˜‘6ŠzØ—‘˜˜Q™•à—‘˜•ð	ô �Q‹<Ðð 
×	Ò	ä�‹VˆØ&'Ö) ‰a”�A“˜‘�nÐ)ˆÐ)ô �Q‹<Ðð Ö ˜ˆa�!‹eÐ ˆÐ ä�Q‹<Ðùò	 *ùâ s   Á/B4ÂB9c                 ó^   — t        | D �cg c]  }t        |||dz
  |«      ‘Œ c}|«      S c c}w )a9  
    Reduce a ``K[X]`` polynomial modulo a polynomial ``p`` in ``K[Y]``.

    Examples
    ========

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

    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
    >>> g = (y - 1).drop(x)

    >>> R.dmp_trunc(f, g)
    11*x**2 + 11*x + 5

    r0   )r   r   )r7   r}   rC   r9   r<   s        r?   Ú	dmp_truncr�   Ò  s.   € ô" ¸Ö;°1”w˜q ! Q¨¡U¨AÕ.Ò;¸QÓ?Ð?ùÒ;s   Š*c                 ó€   — |st        | ||«      S |dz
  }t        | D �cg c]  }t        ||||«      ‘Œ c}|«      S c c}w )a   
    Reduce a ``K[X]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

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

    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3

    >>> R.dmp_ground_trunc(f, ZZ(3))
    -x**2 - x*y - y

    r0   )r   r   Údmp_ground_trunc)r7   r}   rC   r9   rD   r<   s         r?   rƒ   rƒ   æ  sF   € ñ  Ü˜˜A˜qÓ!Ð!à	ˆA‰€Aä¸QÖ@¸Ô'¨¨1¨a°Õ3Ò@À!ÓDÐDùÒ@s   ž;c                 ób   — | s| S t        | |«      }|j                  |«      r| S t        | ||«      S )a7  
    Divide all coefficients by ``LC(f)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x = ring("x", ZZ)
    >>> R.dup_monic(3*x**2 + 6*x + 9)
    x**2 + 2*x + 3

    >>> R, x = ring("x", QQ)
    >>> R.dup_monic(3*x**2 + 4*x + 2)
    x**2 + 4/3*x + 2/3

    )r   Úis_oner   )r7   r9   Úlcs      r?   Ú	dup_monicr‡   þ  s6   € ñ$ Øˆä	��1‹€Bà‡x�x�„|Øˆä  2 qÓ)Ð)rA   c                 ó–   — |st        | |«      S t        | |«      r| S t        | ||«      }|j                  |«      r| S t	        | |||«      S )aÃ  
    Divide all coefficients by ``LC(f)`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x,y = ring("x,y", ZZ)
    >>> f = 3*x**2*y + 6*x**2 + 3*x*y + 9*y + 3

    >>> R.dmp_ground_monic(f)
    x**2*y + 2*x**2 + x*y + 3*y + 1

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3

    >>> R.dmp_ground_monic(f)
    x**2*y + 8/3*x**2 + 5/3*x*y + 2*x + 2/3*y + 1

    )r‡   r&   r!   r…   r   )r7   rC   r9   r†   s       r?   Údmp_ground_monicr‰     sQ   € ñ, Ü˜˜A‹Ðä�!�QÔØˆä	�q˜!˜QÓ	€Bà‡x�x�„|Øˆä  2 q¨!Ó,Ð,rA   c                 óà   — ddl m} | s|j                  S |j                  }||k(  r| D ]  }|j                  ||«      }Œ |S | D ](  }|j                  ||«      }|j	                  |«      sŒ' |S  |S )aA  
    Compute the GCD of coefficients of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x = ring("x", ZZ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_content(f)
    2

    >>> R, x = ring("x", QQ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_content(f)
    2

    r   ©ÚQQ)Úsympy.polys.domainsrŒ   r1   Úgcdr…   )r7   r9   rŒ   Úcontr<   s        r?   Údup_contentr�   ?  s‚   € õ, 'áØ�v‰vˆà�6‰6€DàˆB‚wØò 	"ˆAØ—5‘5˜˜q“>‰Dð	"ð €Kð ò 	ˆAØ—5‘5˜˜q“>ˆDà�x‰x˜�~Øà€Kð	ð €KrA   c           	      óF  — ddl m} |st        | |«      S t        | |«      r|j                  S |j                  |dz
  }}||k(  r&| D ]  }|j                  |t        |||«      «      }Œ! |S | D ]3  }|j                  |t        |||«      «      }|j                  |«      sŒ2 |S  |S )aa  
    Compute the GCD of coefficients of ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x,y = ring("x,y", ZZ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_content(f)
    2

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_content(f)
    2

    r   r‹   r0   )r�   rŒ   r�   r&   r1   rŽ   Údmp_ground_contentr…   )r7   rC   r9   rŒ   r�   rD   r<   s          r?   r’   r’   i  s·   € õ, 'áÜ˜1˜aÓ Ð ä�!�QÔØ�v‰vˆà�f‰f�a˜!‘eˆ!€DàˆB‚wØò 	<ˆAØ—5‘5˜Ô1°!°Q¸Ó:Ó;‰Dð	<ð €Kð ò 	ˆAØ—5‘5˜Ô1°!°Q¸Ó:Ó;ˆDà�x‰x˜�~Øà€Kð	ð €KrA   c                 ó‚   — | s|j                   | fS t        | |«      }|j                  |«      r|| fS |t        | ||«      fS )at  
    Compute content and the primitive form of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x = ring("x", ZZ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_primitive(f)
    (2, 3*x**2 + 4*x + 6)

    >>> R, x = ring("x", QQ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_primitive(f)
    (2, 3*x**2 + 4*x + 6)

    )r1   r�   r…   r   )r7   r9   r�   s      r?   Údup_primitiver”   –  sI   € ñ, Ø�v‰v�qˆyÐä�q˜!Ó€Dà‡x�x�„~Ø�Qˆwˆà”^ A t¨QÓ/Ð/Ð/rA   c                 ó¶   — |st        | |«      S t        | |«      r|j                  | fS t        | ||«      }|j	                  |«      r|| fS |t        | |||«      fS )aš  
    Compute content and the primitive form of ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x,y = ring("x,y", ZZ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_primitive(f)
    (2, x*y + 3*x + 2*y + 6)

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_primitive(f)
    (2, x*y + 3*x + 2*y + 6)

    )r”   r&   r1   r’   r…   r   )r7   rC   r9   r�   s       r?   Údmp_ground_primitiver–   ·  sd   € ñ, Ü˜Q Ó"Ð"ä�!�QÔØ�v‰v�qˆyÐä˜a  AÓ&€Dà‡x�x�„~Ø�Qˆwˆà”^ A t¨Q°Ó2Ð2Ð2rA   c                 ó¶   — t        | |«      }t        ||«      }|j                  ||«      }|j                  |«      st        | ||«      } t        |||«      }|| |fS )a  
    Extract common content from a pair of polynomials in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_extract(6*x**2 + 12*x + 18, 4*x**2 + 8*x + 12)
    (2, 3*x**2 + 6*x + 9, 2*x**2 + 4*x + 6)

    )r�   rŽ   r…   r   )r7   r:   r9   ÚfcÚgcrŽ   s         r?   Údup_extractrš   Û  s^   € ô 
�Q˜Ó	€BÜ	�Q˜Ó	€Bà
�%‰%��B‹-€Cà�8‰8�CŒ=Ü˜1˜c 1Ó%ˆÜ˜1˜c 1Ó%ˆà��1ˆ9ÐrA   c                 ó¾   — t        | ||«      }t        |||«      }|j                  ||«      }|j                  |«      st        | |||«      } t        ||||«      }|| |fS )a  
    Extract common content from a pair of polynomials in ``K[X]``.

    Examples
    ========

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

    >>> R.dmp_ground_extract(6*x*y + 12*x + 18, 4*x*y + 8*x + 12)
    (2, 3*x*y + 6*x + 9, 2*x*y + 4*x + 6)

    )r’   rŽ   r…   r   )r7   r:   rC   r9   r˜   r™   rŽ   s          r?   Údmp_ground_extractrœ   õ  sf   € ô 
˜A˜q !Ó	$€BÜ	˜A˜q !Ó	$€Bà
�%‰%��B‹-€Cà�8‰8�CŒ=Ü˜1˜c 1 aÓ(ˆÜ˜1˜c 1 aÓ(ˆà��1ˆ9ÐrA   c                 ó<  — |j                   s|j                  st        d|z  «      ‚t        d«      }t        d«      }| s||fS |j                  |j
                  gg|j                  gg gg}t        | d   d«      }| dd D ])  }t        ||d|«      }t        |t        |d«      dd|«      }Œ+ t        |«      }|j                  «       D ]Q  \  }}|dz  }	|	st        ||d|«      }Œ|	dk(  rt        ||d|«      }Œ0|	dk(  rt        ||d|«      }ŒDt        ||d|«      }ŒS ||fS )aý  
    Find ``f1`` and ``f2``, such that ``f(x+I*y) = f1(x,y) + f2(x,y)*I``.

    Examples
    ========

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

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

    >>> from sympy.abc import x, y, z
    >>> from sympy import I
    >>> (z**3 + z**2 + z + 1).subs(z, x+I*y).expand().collect(I)
    x**3 + x**2 - 3*x*y**2 + x - y**2 + I*(3*x**2*y + 2*x*y - y**3 + y) + 1

    z;computing real and imaginary parts is not supported over %sr0   r   ry   Né   )rz   Úis_QQr+   r$   Úoner1   r%   r   r   r'   Úitemsr   r	   )
r7   r9   Úf1Úf2r:   ro   r<   ÚHrT   r8   s
             r?   Údup_real_imagr¥     s<  € ð& �7Š7˜1Ÿ7š7ÜÐWÐZ[Ñ[Ó\Ð\ä	�!‹€BÜ	�!‹€BáØ�2ˆvˆà�5‰5�!—&‘&ˆ/Ð	˜aŸe™e˜W b˜MÐ*€AÜ�1�Q‘4˜Ó€AàˆqˆrˆUò 7ˆÜ�A�q˜!˜QÓˆÜ˜œJ q¨!Ó,¨a°°AÓ6‰ð7ô 	˜Ó€Aà—‘“	ò 
&‰ˆˆ1Ø�‰EˆáÜ˜˜Q  1Ó%‰BØ�!ŠVÜ˜˜Q  1Ó%‰BØ�!ŠVÜ˜˜Q  1Ó%‰Bä˜˜Q  1Ó%‰Bð
&ð ˆrˆ6€MrA   c                 ój   — t        | «      } t        t        | «      dz
  dd«      D ]  }| |    | |<   Œ | S )zô
    Evaluate efficiently the composition ``f(-x)`` in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_mirror(x**3 + 2*x**2 - 4*x + 2)
    -x**3 + 2*x**2 + 4*x + 2

    ry   rP   éþÿÿÿ)Úlistr4   rm   )r7   r9   r;   s      r?   Ú
dup_mirrorr©   C  sC   € ô 	ˆQ‹€Aä”3�q“6˜A‘:˜r 2Ó&ò ˆØ�!‘ˆuˆˆ!Šðð €HrA   c                 óˆ   — t        | «      t        | «      dz
  |}}} t        |dz
  dd«      D ]  }|| |   z  ||z  c| |<   }Œ | S )zæ
    Evaluate efficiently composition ``f(a*x)`` in ``K[x]``.

    Examples
    ========

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

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

    r0   rP   ©r¨   rm   r4   )r7   rb   r9   r=   Úbr;   s         r?   Ú	dup_scaler­   Y  s[   € ô �1‹g”s˜1“v ‘z 1ˆ!€q€Aä�1�q‘5˜"˜bÓ!ò ˆØ�A�a‘D‘&˜!˜A™#ˆˆˆ!‰‰aðð €HrA   c                 óª   — t        | «      t        | «      dz
  }} t        |dd«      D ])  }t        d|«      D ]  }| |dz   xx   || |   z  z  cc<   Œ Œ+ | S )zç
    Evaluate efficiently Taylor shift ``f(x + a)`` in ``K[x]``.

    Examples
    ========

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

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

    r0   r   rP   r«   )r7   rb   r9   r=   r;   r>   s         r?   Ú	dup_shiftr¯   o  sf   € ô �‹7”C˜“F˜Q‘J€q€Aä�1�a˜‹_ò ˆÜ�q˜!“ò 	ˆAØˆa�!‰e‹H˜˜!˜A™$™ÑŒHñ	ðð €HrA   c           	      ód  — |st        | |d   |«      S t        | |«      r| S |d   |dd }}| D �cg c]  }t        |||dz
  |«      ‘Œ } }t        | «      dz
  }t	        |dd«      D ]D  }t	        d|«      D ]3  }	t        | |	   ||dz
  |«      }
t        | |	dz      |
|dz
  |«      | |	dz   <   Œ5 ŒF | S c c}w )a°  
    Evaluate efficiently Taylor shift ``f(X + A)`` in ``K[X]``.

    Examples
    ========

    >>> from sympy import symbols, ring, ZZ
    >>> x, y = symbols('x y')
    >>> R, _, _ = ring([x, y], ZZ)

    >>> p = x**2*y + 2*x*y + 3*x + 4*y + 5

    >>> R.dmp_shift(R(p), [ZZ(1), ZZ(2)])
    x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22

    >>> p.subs({x: x + 1, y: y + 2}).expand()
    x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22
    r   r0   NrP   )r¯   r&   Ú	dmp_shiftrm   r4   r   r   )r7   rb   rC   r9   Úa0Úa1r<   r=   r;   r>   Úafjs              r?   r±   r±   †  sß   € ñ& Ü˜˜A˜a™D !Ó$Ð$ä�!�QÔØˆàˆq‰T�1�Q�R�5ˆ€Bà,-Ö/ qŒ)�A�r˜1˜Q™3 Õ
"Ð/€AÐ/ÜˆA‹�‰
€Aä�1�a˜‹_ò 6ˆÜ�q˜!“ò 	6ˆAÜ   1¡ r¨1¨Q©3°Ó2ˆCÜ˜q  Q¡™x¨¨a°©c°1Ó5ˆAˆa�!‰eŠHñ	6ð6ð
 €Hùò 	0s   ¯B-c                 ó4  — | sg S t        | «      dz
  }| d   g|j                  gg}}t        d|«      D ]!  }|j                  t	        |d   ||«      «       Œ# t        | dd |dd «      D ],  \  }}t	        |||«      }t        |||«      }t        |||«      }Œ. |S )a  
    Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_transform(x**2 - 2*x + 1, x**2 + 1, x - 1)
    x**4 - 2*x**3 + 5*x**2 - 4*x + 4

    r0   r   rP   N)rm   r    r4   rQ   r
   Úzipr   r   )	r7   r}   Úqr9   r=   ro   ÚQr;   r<   s	            r?   Údup_transformr¹   ¬  s·   € ñ Øˆ	äˆA‹�‰
€AØˆa‰Dˆ6�Q—U‘U�G�9€q€Aä�1�a‹[ò 'ˆØ	�‰”˜˜2™  1Ó%Õ&ð'ô �A�a�b�E˜1˜Q˜R˜5Ó!ò ‰ˆˆ1Ü�A�q˜!ÓˆÜ˜1˜a Ó#ˆÜ�A�q˜!Ó‰ðð
 €HrA   c           	      óÂ   — t        |«      dk  r!t        t        | t        ||«      |«      g«      S | sg S | d   g}| dd D ]  }t	        |||«      }t        ||d|«      }Œ |S )z×
    Evaluate functional composition ``f(g)`` in ``K[x]``.

    Examples
    ========

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

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

    r0   r   N)rm   r   rd   r   r
   r   )r7   r:   r9   ro   r<   s        r?   Údup_composer»   Ë  sy   € ô ˆ1ƒv�‚{Üœ( 1¤f¨Q°£l°AÓ6Ð7Ó8Ð8áØˆ	à	
ˆ1‰ˆ€AàˆqˆrˆUò %ˆÜ�A�q˜!ÓˆÜ˜˜A˜q !Ó$‰ð%ð €HrA   c                 óš   — |st        | ||«      S t        | |«      r| S | d   g}| dd D ]  }t        ||||«      }t        ||d||«      }Œ! |S )zÞ
    Evaluate functional composition ``f(g)`` in ``K[X]``.

    Examples
    ========

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

    >>> R.dmp_compose(x*y + 2*x + y, y)
    y**2 + 3*y

    r   r0   N)r»   r&   r   r   )r7   r:   rC   r9   ro   r<   s         r?   Údmp_composer½   è  sn   € ñ Ü˜1˜a Ó#Ð#ä�!�QÔØˆà	
ˆ1‰ˆ€AàˆqˆrˆUò (ˆÜ�A�q˜!˜QÓˆÜ˜˜A˜q ! QÓ'‰ð(ð €HrA   c                 ó�  — t        | «      dz
  }t        | |«      }t        | «      } ||j                  i}||z  }t	        d|«      D ]t  }|j
                  }t	        d|«      D ]9  }	||	z   |z
  | vrŒ||	z
  |vrŒ| ||	z   |z
     |||	z
     }}
||||	z  z
  |
z  |z  z  }Œ; |j                  |||z  |z  «      |||z
  <   Œv t        ||«      S )ú+Helper function for :func:`_dup_decompose`.r0   r   )rm   r   r'   r    r4   r1   Úquor(   )r7   Úsr9   r=   r†   r:   Úrr;   rS   r>   r˜   r™   s               r?   Ú_dup_right_decomposerÃ     sõ   € äˆA‹�‰
€AÜ	��1‹€Bä˜Ó€AØ
ˆQ�U‰Uˆ€Aà	ˆQ‰€Aä�1�a‹[ò (ˆØ—‘ˆä�q˜!“ò 	%ˆAØ�q‘5˜1‘9 ‘>Øà�q‘5˜A‘:Øà�q˜1‘u˜q‘y‘\ 1 Q¨¡U¡8�ˆBØ�a˜!˜A™#‘g˜r‘\ "‘_Ñ$‰Eð	%ð —5‘5˜  !¡ B¡Ó'ˆˆ!ˆa‰%Šð(ô ˜Q Ó"Ð"rA   c                 ó–   — i d}}| r8t        | ||«      \  }}t        |«      dkD  ryt        ||«      ||<   ||dz   }} | rŒ8t        ||«      S )r¿   r   Nr0   )r   r   r   r(   )r7   ro   r9   r:   r;   r·   rÂ   s          r?   Ú_dup_left_decomposerÅ   !  s_   € àˆq€q€Aá
Ü�q˜!˜QÓ‰ˆˆ1ä�a‹=˜1ÒØä˜!˜Q“<ˆAˆa‰DØ�a˜!‘eˆqˆAò ô ˜Q Ó"Ð"rA   c                 óž   — t        | «      dz
  }t        d|«      D ]0  }||z  dk7  rŒt        | ||«      }|€Œt        | ||«      }|€Œ,||fc S  y)z*Helper function for :func:`dup_decompose`.r0   ry   r   N)rm   r4   rÃ   rÅ   )r7   r9   ÚdfrÁ   ro   r:   s         r?   Ú_dup_decomposerÈ   1  sf   € ä	ˆQ‹�!‰€Bä�1�b‹\ò 
ˆØ�‰6�QŠ;Øä   A qÓ)ˆà‰=Ü# A q¨!Ó,ˆAà‰}Ø˜!�t’ð
ð rA   c                 óL   — g }	 t        | |«      }|�|\  } }|g|z   }nnŒ| g|z   S )ae  
    Computes functional decomposition of ``f`` in ``K[x]``.

    Given a univariate polynomial ``f`` with coefficients in a field of
    characteristic zero, returns list ``[f_1, f_2, ..., f_n]``, where::

              f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))

    and ``f_2, ..., f_n`` are monic and homogeneous polynomials of at
    least second degree.

    Unlike factorization, complete functional decompositions of
    polynomials are not unique, consider examples:

    1. ``f o g = f(x + b) o (g - b)``
    2. ``x**n o x**m = x**m o x**n``
    3. ``T_n o T_m = T_m o T_n``

    where ``T_n`` and ``T_m`` are Chebyshev polynomials.

    Examples
    ========

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

    >>> R.dup_decompose(x**4 - 2*x**3 + x**2)
    [x**2, x**2 - x]

    References
    ==========

    .. [1] [Kozen89]_

    )rÈ   )r7   r9   ÚFrc   ro   s        r?   Údup_decomposerË   D  sH   € ðH 	€Aà
Ü  1Ó%ˆàÐØ‰DˆAˆqØ��a‘‰Aàð ð ˆ3�‰7€NrA   c                 ó.  — |j                   r |j                  «       }t        | |||«      } |}|j                  st	        d«      ‚t        | |«      g g }}}|j                  «       D ]#  \  }}|j                  rŒ|j                  |«       Œ% t        ddgt        |«      d¬«      }	|	D ]L  }
t        |«      }t        |
|«      D ]  \  }}|dk(  sŒ||    ||<   Œ |j                  t        |||«      «       ŒN t        t        |||«      |||j                  «      S )a^  
    Convert algebraic coefficients to integers in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> from sympy import I

    >>> K = QQ.algebraic_field(I)
    >>> R, x = ring("x", K)

    >>> f = x**2 + K([QQ(1), QQ(0)])*x + K([QQ(2), QQ(0)])

    >>> R.dmp_lift(f)
    x**8 + 2*x**6 + 9*x**4 - 8*x**2 + 16

    z3computation can be done only in an algebraic domainrP   r0   T)Ú
repetition)Úis_GaussianFieldÚas_AlgebraicFieldr   Úis_Algebraicr+   r   r¡   Ú	is_groundrQ   r,   rm   Údictr¶   r   r   Údom)r7   rC   r9   ÚK1rÊ   ÚmonomsÚpolysÚmonomrS   ÚpermsÚpermÚGÚsigns                r?   Údmp_liftrÜ   v  s"  € ð& 	×ÒØ× Ñ Ó"ˆÜ˜˜1˜a Ó$ˆØˆà�>Š>ÜØAóCð 	Cô # 1 aÓ(¨"¨bˆu€v€AàŸ™›	ò !‰ˆˆuØ�‹Ø�M‰M˜%Õ ð!ô ˜˜A�w¤ F£¸Ô=€Eàò -ˆÜ�‹Gˆä˜t VÓ,ò 	%‰KˆD�%Ø�r‹zØ˜e™H˜9��%’ð	%ð 	�‰”] 1 a¨Ó+Õ,ð-ô ”z %¨¨AÓ.°°1°a·e±eÓ<Ð<rA   c                 ól   — |j                   d}}| D ]   }|j                  ||z  «      r|dz  }|sŒ|}Œ" |S )zâ
    Compute the number of sign variations of ``f`` in ``K[x]``.

    Examples
    ========

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

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

    r   r0   )r1   Úis_negative)r7   r9   ÚprevrT   rS   s        r?   Údup_sign_variationsrà   ¦  sH   € ð �f‰f�aˆ!€Dàò ˆØ�=‰=˜˜t™Ô$Ø�‰FˆAâØ‰Dðð €HrA   Nc           
      ó¬  — |€|j                   r|j                  «       }n|}|j                  }| D ]#  }|j                  ||j	                  |«      «      }Œ% |j                  |«      r|s|| fS |t        | ||«      fS | D �cg c]5  }|j                  |«      |j                  ||j	                  |«      «      z  ‘Œ7 } }|s|t        | ||«      fS || fS c c}w )a@  
    Clear denominators, i.e. transform ``K_0`` to ``K_1``.

    Examples
    ========

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

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

    >>> R.dup_clear_denoms(f, convert=False)
    (6, 3*x + 2)
    >>> R.dup_clear_denoms(f, convert=True)
    (6, 3*x + 2)

    )	Úhas_assoc_RingÚget_ringr    ÚlcmÚdenomr…   r   ÚnumerrÀ   )r7   ÚK0rÔ   ra   Úcommonr<   s         r?   Údup_clear_denomsré   À  sÜ   € ð$ 
€zØ×ÒØ—‘“‰BàˆBà�V‰V€Fàò -ˆØ—‘˜ §¡¨£Ó,‰ð-ð 
‡y�y�ÔÙØ˜1�9Ðàœ; q¨"¨bÓ1Ð1Ð1ð ;<Ö<°Qˆ�‰�!‹�R—V‘V˜F B§H¡H¨Q£KÓ0Ó	0Ð<€AÐ<áØ”{ 1 b¨"Ó-Ð-Ð-à�qˆyÐùò 	=s   Â :Cc           
      óÊ   — |j                   }|s*| D ]#  }|j                  ||j                  |«      «      }Œ% |S |dz
  }| D ]   }|j                  |t        ||||«      «      }Œ" |S )z.Recursive helper for :func:`dmp_clear_denoms`.r0   )r    rä   rå   Ú_rec_clear_denoms)r:   rD   rç   rÔ   rè   r<   rI   s          r?   rë   rë   í  s{   € à�V‰V€FáØò 	1ˆAØ—V‘V˜F B§H¡H¨Q£KÓ0‰Fð	1ð €Mð �‰Eˆàò 	EˆAØ—V‘V˜FÔ$5°a¸¸BÀÓ$CÓD‰Fð	Eð €MrA   c                 óì   — |st        | |||¬«      S |€|j                  r|j                  «       }n|}t        | |||«      }|j	                  |«      st        | |||«      } |s|| fS |t        | |||«      fS )aV  
    Clear denominators, i.e. transform ``K_0`` to ``K_1``.

    Examples
    ========

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

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

    >>> R.dmp_clear_denoms(f, convert=False)
    (6, 3*x + 2*y + 6)
    >>> R.dmp_clear_denoms(f, convert=True)
    (6, 3*x + 2*y + 6)

    )ra   )ré   râ   rã   rë   r…   r   r   )r7   rC   rç   rÔ   ra   rè   s         r?   Údmp_clear_denomsrí   ý  s…   € ñ$ Ü  2 r°7Ô;Ð;à	€zØ×ÒØ—‘“‰BàˆBä˜q ! R¨Ó,€Fà�9‰9�VÔÜ˜1˜f a¨Ó,ˆáØ�qˆyÐà”{ 1 a¨¨RÓ0Ð0Ð0rA   c                 ó–  — |j                  t        | |«      «      g}|j                  |j                  |j                  g}t	        t        t        |«      «      «      }t        d|dz   «      D ]Z  }t        | |d«      |«      }t        | t        ||«      |«      }t        t        |||«      ||«      }t        |t        |«      |«      }Œ\ |S )a÷  
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

    This function computes first ``2**n`` terms of a polynomial that
    is a result of inversion of a polynomial modulo ``x**n``. This is
    useful to efficiently compute series expansion of ``1/f``.

    Examples
    ========

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

    >>> f = -QQ(1,720)*x**6 + QQ(1,24)*x**4 - QQ(1,2)*x**2 + 1

    >>> R.dup_revert(f, 8)
    61/720*x**6 + 5/24*x**4 + 1/2*x**2 + 1

    r0   ry   )Úrevertr"   r    r1   r|   Ú_ceilÚ_log2r4   r   r
   r   r   r   r   r   )	r7   r=   r9   r:   ro   ÚNr;   rb   r¬   s	            r?   Ú
dup_revertró   #  s´   € ð( 
�‰”&˜˜A“,Ó	Ð €AØ	
�‰�—‘˜Ÿ™Ð€AäŒE”%˜“(‹OÓ€Aä�1�a˜!‘e‹_ò ,ˆÜ˜1™a ›d AÓ&ˆÜ�A”w˜q !“} aÓ(ˆÜ”G˜A˜q !Ó$ a¨Ó+ˆÜ�qœ* Q›-¨Ó+‰ð	,ð €HrA   c                 ó8   — |st        | ||«      S t        | |«      ‚)z©
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

    Examples
    ========

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

    )ró   r*   )r7   r:   rC   r9   s       r?   Ú
dmp_revertrõ   E  s#   € ñ Ü˜!˜Q Ó"Ð"ä)¨!¨QÓ/Ð/rA   )NF)bÚ__doc__Úsympy.polys.densearithr   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.polyerrorsr*   r+   Úsympy.utilitiesr,   Úmathr-   rð   r.   rñ   r@   rE   rG   rN   rU   rW   rY   r^   rd   rf   rh   rj   rl   rr   rt   rw   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õ   © rA   r?   ú<module>rý      sO  ðÙ N÷÷ ÷ ÷ ÷ ó ÷÷ ÷ ÷ ÷ ñ ÷õ 'ç -òò@ òFLò/ò,(òV,ò^Gò*ò0ò4ò:Gò*ò0
1ò(ò@Lò/ò4òD@ò(Eò0*ò:!-òH'òT*òZ0òB!3òHò4ò41òhò,ò,ò.#òLò>ò:ò:#ò8#ò ò&/òd-=ò`ó4*òZó #1òLóD0rA   