§
    ^²Åjª%  ã                   ó�  — d Z ddlZddlmZ ddlmZ ddlmZ ddlm	Z	 ddl
mZ ddlmZ dd	lmZmZ dd
lmZ ddlmZ ddlmZ edk    rdgZedk    r>ddlZej                             d¦  «        ^ZZZ ee¦  «         ee¦  «        fdk     rdZndZd„ Ze eddg¬¦  «         G d„ de	e¦  «        ¦   «         ¦   «         Z e xZ!Z"dS )z.Implementation of :class:`FiniteField` class. é    N)ÚGROUND_TYPES)Údoctest_depends_on)Ú
int_valued)ÚField)ÚModularIntegerFactory)ÚSimpleDomain)Úgf_zassenhausÚgf_irred_p_rabin)ÚCoercionFailed)Úpublic)ÚSymPyIntegerÚflintÚFiniteFieldú.)r   é   c                 ó²  ‡ ‡‡‡— t           �»t           j        Št           j        }t          j        Š	 |                     ‰ ¦  «        Š n # t          $ r t          d‰ z  ¦  «        ‚w xY w	  |‰ ¦  «         n# t          $ r  ‰‰ ¦  «        Š Y nw xY w	  ‰d‰ ¦  «         ˆˆ ˆfd„}n!# t          $ r  |‰ ¦  «        Šˆˆfd„}Y nw xY w|S t          ‰ |||¦  «        S )Nz"modulus must be an integer, got %sr   c                 óh   •— 	  ‰| ‰¦  «        S # t           $ r  ‰ ‰| ¦  «        ‰¦  «        cY S w xY w©N©Ú	TypeError)ÚxÚindexÚmodÚnmods    €€€úPC:\Projects\Historical\venv\Lib\site-packages\sympy/polys/domains/finitefield.pyÚctxz!_modular_int_factory.<locals>.ctxE   sS   ø€ ð/Ø˜4  3™<œ<Ð'øÝ ð /ð /ð /Ø˜4   a¡¤¨#Ñ.Ô.Ð.Ð.Ð.ð/øøøs   ƒ �1°1c                 ód   •— 	  ‰| ¦  «        S # t           $ r  ‰ ‰| ¦  «        ¦  «        cY S w xY wr   r   )r   Úfctxr   s    €€r   r   z!_modular_int_factory.<locals>.ctx=   sL   ø€ ð*Ø˜4 ™7œ7�NøÝ ð *ð *ð *à˜4   a¡¤™>œ>Ð)Ð)Ð)ð*øøøs   ƒ
 Ž/®/)r   r   Úfmpz_mod_ctxÚoperatorr   Úconvertr   Ú
ValueErrorr   ÚOverflowErrorr   )	r   ÚdomÚ	symmetricÚselfr   r   r   r   r   s	   `     @@@r   Ú_modular_int_factoryr'   "   sa  øøøø€ õ ÐåŒzˆÝÔ)ˆÝ”ˆð	IØ—+’+˜cÑ"Ô"ˆCˆCøÝð 	Ið 	Ið 	IÝÐAÀCÑGÑHÔHÐHð	Iøøøð	ØˆL˜ÑÔÐÐøÝð 	ð 	ð 	Ø�%˜‘*”*ˆCˆCˆCð	øøøð	/ØˆD��C‰LŒLˆLð/ð /ð /ð /ð /ð /ð /ð /øõ ð 		*ð 		*ð 		*à�< Ñ$Ô$ˆDð*ð *ð *ð *ð *ð *ð *ð *ð			*øøøð$ ˆ
õ !  c¨9°dÑ;Ô;Ð;s/   ±A ÁA$Á(A4 Á4BÂBÂB$ Â$CÃCÚpythonÚgmpy)Úmodulesc                   óö   — e Zd ZdZdZdZdxZZdZdZ	dZ
dZdZd d„Zed„ ¦   «         Zd„ Zd	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd!d„Zd!d„Zd!d„Zd!d„Zd!d„Z d!d„Z!d!d„Z"d!d„Z#d!d„Z$d„ Z%d„ Z&d„ Z'dS )"r   a	  Finite field of prime order :ref:`GF(p)`

    A :ref:`GF(p)` domain represents a `finite field`_ `\mathbb{F}_p` of prime
    order as :py:class:`~.Domain` in the domain system (see
    :ref:`polys-domainsintro`).

    A :py:class:`~.Poly` created from an expression with integer
    coefficients will have the domain :ref:`ZZ`. However, if the ``modulus=p``
    option is given then the domain will be a finite field instead.

    >>> from sympy import Poly, Symbol
    >>> x = Symbol('x')
    >>> p = Poly(x**2 + 1)
    >>> p
    Poly(x**2 + 1, x, domain='ZZ')
    >>> p.domain
    ZZ
    >>> p2 = Poly(x**2 + 1, modulus=2)
    >>> p2
    Poly(x**2 + 1, x, modulus=2)
    >>> p2.domain
    GF(2)

    It is possible to factorise a polynomial over :ref:`GF(p)` using the
    modulus argument to :py:func:`~.factor` or by specifying the domain
    explicitly. The domain can also be given as a string.

    >>> from sympy import factor, GF
    >>> factor(x**2 + 1)
    x**2 + 1
    >>> factor(x**2 + 1, modulus=2)
    (x + 1)**2
    >>> factor(x**2 + 1, domain=GF(2))
    (x + 1)**2
    >>> factor(x**2 + 1, domain='GF(2)')
    (x + 1)**2

    It is also possible to use :ref:`GF(p)` with the :py:func:`~.cancel`
    and :py:func:`~.gcd` functions.

    >>> from sympy import cancel, gcd
    >>> cancel((x**2 + 1)/(x + 1))
    (x**2 + 1)/(x + 1)
    >>> cancel((x**2 + 1)/(x + 1), domain=GF(2))
    x + 1
    >>> gcd(x**2 + 1, x + 1)
    1
    >>> gcd(x**2 + 1, x + 1, domain=GF(2))
    x + 1

    When using the domain directly :ref:`GF(p)` can be used as a constructor
    to create instances which then support the operations ``+,-,*,**,/``

    >>> from sympy import GF
    >>> K = GF(5)
    >>> K
    GF(5)
    >>> x = K(3)
    >>> y = K(2)
    >>> x
    3 mod 5
    >>> y
    2 mod 5
    >>> x * y
    1 mod 5
    >>> x / y
    4 mod 5

    Notes
    =====

    It is also possible to create a :ref:`GF(p)` domain of **non-prime**
    order but the resulting ring is **not** a field: it is just the ring of
    the integers modulo ``n``.

    >>> K = GF(9)
    >>> z = K(3)
    >>> z
    3 mod 9
    >>> z**2
    0 mod 9

    It would be good to have a proper implementation of prime power fields
    (``GF(p**n)``) but these are not yet implemented in SymPY.

    .. _finite field: https://en.wikipedia.org/wiki/Finite_field
    ÚFFTFNc                 ó8  — ddl m} |}|dk    rt          d|z  ¦  «        ‚t          |||| ¦  «        | _        |                      d¦  «        | _        |                      d¦  «        | _        || _        || _        || _	        t          | j        ¦  «        | _        d S )Nr   )ÚZZz*modulus must be a positive integer, got %sé   )Úsympy.polys.domainsr.   r"   r'   ÚdtypeÚzeroÚoner$   r   ÚsymÚtypeÚ_tp)r&   r   r%   r.   r$   s        r   Ú__init__zFiniteField.__init__¸   s•   € Ø*Ð*Ð*Ð*Ð*Ð*Øˆà�!Š8ˆ8ÝÐIÈCÑOÑPÔPÐPå)¨#¨s°I¸tÑDÔDˆŒ
Ø—J’J˜q‘M”MˆŒ	Ø—:’:˜a‘=”=ˆŒØˆŒØˆŒØˆŒÝ˜œ	‘?”?ˆŒˆˆó    c                 ó   — | j         S r   )r6   ©r&   s    r   ÚtpzFiniteField.tpÇ   ó	   € àŒxˆr8   c                 ó   — d| j         z  S )NzGF(%s)©r   r:   s    r   Ú__str__zFiniteField.__str__Ë   s   € Ø˜$œ(Ñ"Ð"r8   c                 óZ   — t          | j        j        | j        | j        | j        f¦  «        S r   )ÚhashÚ	__class__Ú__name__r1   r   r$   r:   s    r   Ú__hash__zFiniteField.__hash__Î   s$   € Ý�T”^Ô,¨d¬j¸$¼(ÀDÄHÐMÑNÔNÐNr8   c                 ól   — t          |t          ¦  «        o| j        |j        k    o| j        |j        k    S )z0Returns ``True`` if two domains are equivalent. )Ú
isinstancer   r   r$   )r&   Úothers     r   Ú__eq__zFiniteField.__eq__Ñ   s6   € å˜%¥Ñ-Ô-ð <ØŒH˜œ	Ò!ð<Ø&*¤h°%´)Ò&;ð	<r8   c                 ó   — | j         S )z*Return the characteristic of this domain. r>   r:   s    r   ÚcharacteristiczFiniteField.characteristicÖ   r<   r8   c                 ó   — | S )z*Returns a field associated with ``self``. © r:   s    r   Ú	get_fieldzFiniteField.get_fieldÚ   s   € àˆr8   c                 óF   — t          |                      |¦  «        ¦  «        S )z!Convert ``a`` to a SymPy object. )r   Úto_int©r&   Úas     r   Úto_sympyzFiniteField.to_sympyÞ   s   € å˜DŸKšK¨™NœNÑ+Ô+Ð+r8   c                 ó:  — |j         r:|                      | j                             t          |¦  «        ¦  «        ¦  «        S t	          |¦  «        r:|                      | j                             t          |¦  «        ¦  «        ¦  «        S t          d|z  ¦  «        ‚)z0Convert SymPy's Integer to SymPy's ``Integer``. zexpected an integer, got %s)Ú
is_Integerr1   r$   Úintr   r   rP   s     r   Ú
from_sympyzFiniteField.from_sympyâ   s|   € àŒ<ð 	DØ—:’:˜dœhŸnšn­S°©V¬VÑ4Ô4Ñ5Ô5Ð5Ý˜‰]Œ]ð 	DØ—:’:˜dœhŸnšn­S°©V¬VÑ4Ô4Ñ5Ô5Ð5å Ð!>ÀÑ!BÑCÔCÐCr8   c                 ób   — t          |¦  «        }| j        r|| j        dz  k    r
|| j        z  }|S )z,Convert ``val`` to a Python ``int`` object. é   )rU   r4   r   )r&   rQ   Úavals      r   rO   zFiniteField.to_intë   s8   € å�1‰vŒvˆØŒ8ð 	˜˜tœx¨1™}Ò,Ð,Ø�D”HÑˆDØˆr8   c                 ó    — t          |¦  «        S )z#Returns True if ``a`` is positive. )ÚboolrP   s     r   Úis_positivezFiniteField.is_positiveò   s   € å�A‰wŒwˆr8   c                 ó   — dS )z'Returns True if ``a`` is non-negative. TrL   rP   s     r   Úis_nonnegativezFiniteField.is_nonnegativeö   s   € àˆtr8   c                 ó   — dS )z#Returns True if ``a`` is negative. FrL   rP   s     r   Úis_negativezFiniteField.is_negativeú   s   € àˆur8   c                 ó   — | S )z'Returns True if ``a`` is non-positive. rL   rP   s     r   Úis_nonpositivezFiniteField.is_nonpositiveþ   s	   € àˆuˆr8   c                 ó‚   — |                       | j                             t          |¦  «        |j        ¦  «        ¦  «        S ©z.Convert ``ModularInteger(int)`` to ``dtype``. )r1   r$   Úfrom_ZZrU   ©ÚK1rQ   ÚK0s      r   Úfrom_FFzFiniteField.from_FF  s,   € à�xŠx˜œŸš¥s¨1¡v¤v¨r¬vÑ6Ô6Ñ7Ô7Ð7r8   c                 ó‚   — |                       | j                             t          |¦  «        |j        ¦  «        ¦  «        S rd   )r1   r$   Úfrom_ZZ_pythonrU   rf   s      r   Úfrom_FF_pythonzFiniteField.from_FF_python  s.   € à�xŠx˜œ×-Ò-­c°!©f¬f°b´fÑ=Ô=Ñ>Ô>Ð>r8   c                 ó^   — |                       | j                             ||¦  «        ¦  «        S ©z'Convert Python's ``int`` to ``dtype``. ©r1   r$   rk   rf   s      r   re   zFiniteField.from_ZZ
  ó&   € à�xŠx˜œ×-Ò-¨a°Ñ4Ô4Ñ5Ô5Ð5r8   c                 ó^   — |                       | j                             ||¦  «        ¦  «        S rn   ro   rf   s      r   rk   zFiniteField.from_ZZ_python  rp   r8   c                 óP   — |j         dk    r|                      |j        ¦  «        S dS ©z,Convert Python's ``Fraction`` to ``dtype``. r/   N©Údenominatorrk   Ú	numeratorrf   s      r   Úfrom_QQzFiniteField.from_QQ  ó-   € àŒ=˜AÒÐØ×$Ò$ Q¤[Ñ1Ô1Ð1ð Ðr8   c                 óP   — |j         dk    r|                      |j        ¦  «        S dS rs   rt   rf   s      r   Úfrom_QQ_pythonzFiniteField.from_QQ_python  rx   r8   c                 ór   — |                       | j                             |j        |j        ¦  «        ¦  «        S )z.Convert ``ModularInteger(mpz)`` to ``dtype``. )r1   r$   Úfrom_ZZ_gmpyÚvalrf   s      r   Úfrom_FF_gmpyzFiniteField.from_FF_gmpy  s*   € à�xŠx˜œ×+Ò+¨A¬E°2´6Ñ:Ô:Ñ;Ô;Ð;r8   c                 ó^   — |                       | j                             ||¦  «        ¦  «        S )z%Convert GMPY's ``mpz`` to ``dtype``. )r1   r$   r|   rf   s      r   r|   zFiniteField.from_ZZ_gmpy   s&   € à�xŠx˜œ×+Ò+¨A¨rÑ2Ô2Ñ3Ô3Ð3r8   c                 óP   — |j         dk    r|                      |j        ¦  «        S dS )z%Convert GMPY's ``mpq`` to ``dtype``. r/   N)ru   r|   rv   rf   s      r   Úfrom_QQ_gmpyzFiniteField.from_QQ_gmpy$  s+   € àŒ=˜AÒÐØ—?’? 1¤;Ñ/Ô/Ð/ð Ðr8   c                 óœ   — |                      |¦  «        \  }}|dk    r-|                      | j                             |¦  «        ¦  «        S dS )z'Convert mpmath's ``mpf`` to ``dtype``. r/   N)Úto_rationalr1   r$   )rg   rQ   rh   ÚpÚqs        r   Úfrom_RealFieldzFiniteField.from_RealField)  sE   € à�~Š~˜aÑ Ô ‰ˆˆ1à�Š6ˆ6Ø—8’8˜BœFŸLšL¨™OœOÑ,Ô,Ð,ð ˆ6r8   c                 ón   — d„ | j         | j        | fD ¦   «         }t          || j        | j        ¦  «         S )z7Returns True if ``a`` is a quadratic residue modulo p. c                 ó,   — g | ]}t          |¦  «        ‘ŒS rL   ©rU   ©Ú.0r   s     r   ú
<listcomp>z)FiniteField.is_square.<locals>.<listcomp>3  ó   € Ð:Ð:Ð:˜1•�A‘”Ð:Ð:Ð:r8   )r3   r2   r
   r   r$   )r&   rQ   Úpolys      r   Ú	is_squarezFiniteField.is_square0  s=   € ð ;Ð: ¤¨4¬9°q°bÐ 9Ð:Ñ:Ô:ˆÝ# D¨$¬(°D´HÑ=Ô=Ð=Ð=r8   c                 ó$  — | j         dk    s|dk    r|S d„ | j        | j        | fD ¦   «         }t          || j         | j        ¦  «        D ]F}t          |¦  «        dk    r1|d         | j         dz  k    r|                      |d         ¦  «        c S ŒGdS )z·Square root modulo p of ``a`` if it is a quadratic residue.

        Explanation
        ===========
        Always returns the square root that is no larger than ``p // 2``.
        rX   r   c                 ó,   — g | ]}t          |¦  «        ‘ŒS rL   r‰   rŠ   s     r   rŒ   z&FiniteField.exsqrt.<locals>.<listcomp>A  r�   r8   r/   N)r   r3   r2   r	   r$   Úlenr1   )r&   rQ   rŽ   Úfactors       r   ÚexsqrtzFiniteField.exsqrt6  s¢   € ð Œ8�qŠ=ˆ=˜A šF˜FØˆHà:Ð: ¤¨4¬9°q°bÐ 9Ð:Ñ:Ô:ˆÝ# D¨$¬(°D´HÑ=Ô=ð 	-ð 	-ˆFÝ�6‰{Œ{˜aÒÐ F¨1¤I°´¸Q±Ò$>Ð$>Ø—z’z &¨¤)Ñ,Ô,Ð,Ð,Ð,øØˆtr8   )Tr   )(rC   Ú
__module__Ú__qualname__Ú__doc__ÚrepÚaliasÚis_FiniteFieldÚis_FFÚis_NumericalÚhas_assoc_RingÚhas_assoc_Fieldr$   r   r7   Úpropertyr;   r?   rD   rH   rJ   rM   rR   rV   rO   r\   r^   r`   rb   ri   rl   re   rk   rw   rz   r~   r|   r�   r†   r�   r”   rL   r8   r   r   r   Q   s  € € € € € ðVð Vðp €CØ€Eà!Ð!€N�UØ€Là€NØ€Oà
€CØ
€Cð#ð #ð #ð #ð ðð ñ „Xðð#ð #ð #ðOð Oð Oð<ð <ð <ð
ð ð ðð ð ð,ð ,ð ,ðDð Dð Dðð ð ðð ð ðð ð ðð ð ðð ð ð8ð 8ð 8ð 8ð?ð ?ð ?ð ?ð6ð 6ð 6ð 6ð6ð 6ð 6ð 6ð2ð 2ð 2ð 2ð
2ð 2ð 2ð 2ð
<ð <ð <ð <ð4ð 4ð 4ð 4ð0ð 0ð 0ð 0ð
-ð -ð -ð>ð >ð >ðð ð ð ð r8   )#r—   r    Úsympy.external.gmpyr   Úsympy.utilities.decoratorr   Úsympy.core.numbersr   Úsympy.polys.domains.fieldr   Ú"sympy.polys.domains.modularintegerr   Ú sympy.polys.domains.simpledomainr   Úsympy.polys.galoistoolsr	   r
   Úsympy.polys.polyerrorsr   Úsympy.utilitiesr   Úsympy.polys.domains.groundtypesr   Ú__doctest_skip__r   Ú__version__ÚsplitÚ_majorÚ_minorÚ_rU   r'   r   r,   ÚGFrL   r8   r   ú<module>r±      sÂ  ðØ 4Ð 4à €€€à ,Ð ,Ð ,Ð ,Ð ,Ð ,Ø 8Ð 8Ð 8Ð 8Ð 8Ð 8à )Ð )Ð )Ð )Ð )Ð )Ø +Ð +Ð +Ð +Ð +Ð +à DÐ DÐ DÐ DÐ DÐ DØ 9Ð 9Ð 9Ð 9Ð 9Ð 9Ø CÐ CÐ CÐ CÐ CÐ CÐ CÐ CØ 1Ð 1Ð 1Ð 1Ð 1Ð 1Ø "Ð "Ð "Ð "Ð "Ð "Ø 8Ð 8Ð 8Ð 8Ð 8Ð 8ð �7ÒÐØ%�Ðð �7ÒÐØ€L€L€Lð Ô*×0Ò0°Ñ5Ô5Ð€FˆF�QØˆˆF‰Œ�S�S˜‘[”[Ð! FÒ*Ð*Øˆøà€Eð,<ð ,<ð ,<ð^ ØÐ˜X vÐ.Ð/Ñ/Ô/ðrð rð rð rð r�%˜ñ rô rñ 0Ô/ñ „ðrðj Ð €€R€R€Rr8   