Ë
    O/æjª%  ã                   óf  — 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(  r8ddlZej2                  j5                  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"y)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                  Š	 |j                  ‰ «      Š 	  |‰ «       	  ‰d‰ «       ˆˆ ˆfd„}|S t        ‰ |||«      S # t        $ r t        d‰ z  «      ‚w xY w# t        $ r  ‰‰ «      Š Y ŒOw xY w# t        $ r  |‰ «      Šˆˆfd„}Y |S w xY w)Nz"modulus must be an integer, got %sr   c                 óT   •— 	  ‰| ‰«      S # t         $ r  ‰ ‰| «      ‰«      cY S w xY w©N©Ú	TypeError)ÚxÚindexÚmodÚnmods    €€€úb/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/sympy/polys/domains/finitefield.pyÚctxz!_modular_int_factory.<locals>.ctxE   s4   ø€ ð/Ù  3›<Ð'øÜ ò /Ù¡ a£¨#Ó.Ò.ð/ús   ƒ Œ'¦'c                 óP   •— 	  ‰| «      S # t         $ r  ‰ ‰| «      «      cY S w xY wr   r   )r   Úfctxr   s    €€r   r   z!_modular_int_factory.<locals>.ctx=   s.   ø€ ð*Ù ›7�NøÜ ò *á¡ a£›>Ò)ð*ús   ƒ ‹%¤%)r   r   Úfmpz_mod_ctxÚoperatorr   Úconvertr   Ú
ValueErrorr   ÚOverflowErrorr   )	r   ÚdomÚ	symmetricÚselfr   r   r   r   r   s	   `     @@@r   Ú_modular_int_factoryr'   "   sÚ   û€ ô Ðä�z‰zˆÜ×)Ñ)ˆÜ—‘ˆð	IØ—+‘+˜cÓ"ˆCð
	Ù˜Ôð
	/Ù��CŒLö/ð ˆ
ô !  c¨9°dÓ;Ð;øôC ò 	IÜÐAÀCÑGÓHÐHð	Iûô ò 	Ù˜“*ŠCð	ûô ò 		*á Ó$ˆDö*ð ˆ
ð%		*ús/   ¼A7 ÁB Á	B) Á7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'y)"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                 ó  — ddl m} |}|dk  rt        d|z  «      ‚t        |||| «      | _        | j	                  d«      | _        | j	                  d«      | _        || _        || _        || _	        t        | j
                  «      | _        y )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__¸   sv   € Ý*Øˆà�!Š8ÜÐIÈCÑOÓPÐPä)¨#¨s°I¸tÓDˆŒ
Ø—J‘J˜q“MˆŒ	Ø—:‘:˜a“=ˆŒØˆŒØˆŒØˆŒÜ˜Ÿ	™	“?ˆ�ó    c                 ó   — | j                   S r   )r6   ©r&   s    r   ÚtpzFiniteField.tpÇ   ó   € à�x‰xˆr8   c                 ó    — d| j                   z  S )NzGF(%s)©r   r:   s    r   Ú__str__zFiniteField.__str__Ë   s   € Ø˜$Ÿ(™(Ñ"Ð"r8   c                 ó„   — 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©j¸$¿(¹(ÀDÇHÁHÐMÓNÐNr8   c                 óŽ   — t        |t        «      xr4 | j                  |j                  k(  xr | j                  |j                  k(  S )z0Returns ``True`` if two domains are equivalent. )Ú
isinstancer   r   r$   )r&   Úothers     r   Ú__eq__zFiniteField.__eq__Ñ   s;   € ä˜%¤Ó-ò <Ø�H‰H˜Ÿ	™	Ñ!ò<Ø&*§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                 ó6   — t        | j                  |«      «      S )z!Convert ``a`` to a SymPy object. )r   Úto_int©r&   Úas     r   Úto_sympyzFiniteField.to_sympyÞ   s   € ä˜DŸK™K¨›NÓ+Ð+r8   c                 ó  — |j                   r3| j                  | j                  j                  t        |«      «      «      S t	        |«      r3| j                  | j                  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â   sa   € à�<Š<Ø—:‘:˜dŸh™hŸn™n¬S°«VÓ4Ó5Ð5Ü˜Œ]Ø—:‘:˜dŸh™hŸn™n¬S°«VÓ4Ó5Ð5ä Ð!>ÀÑ!BÓCÐCr8   c                 óv   — t        |«      }| j                  r!|| j                  dz  kD  r|| j                  z  }|S )z,Convert ``val`` to a Python ``int`` object. é   )rU   r4   r   )r&   rQ   Úavals      r   rO   zFiniteField.to_intë   s4   € ä�1‹vˆØ�8Š8˜˜tŸx™x¨1™}Ò,Ø�D—H‘HÑˆDØˆr8   c                 ó   — t        |«      S )z#Returns True if ``a`` is positive. )ÚboolrP   s     r   Úis_positivezFiniteField.is_positiveò   s   € ä�A‹wˆr8   c                  ó   — y)z'Returns True if ``a`` is non-negative. TrL   rP   s     r   Úis_nonnegativezFiniteField.is_nonnegativeö   s   € àr8   c                  ó   — y)z#Returns True if ``a`` is negative. FrL   rP   s     r   Úis_negativezFiniteField.is_negativeú   s   € àr8   c                 ó   — | S )z'Returns True if ``a`` is non-positive. rL   rP   s     r   Úis_nonpositivezFiniteField.is_nonpositiveþ   s	   € àˆuˆr8   c                 ó~   — | j                  | j                  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¨r¯v©vÓ6Ó7Ð7r8   c                 ó~   — | j                  | j                  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°b·f±fÓ=Ó>Ð>r8   c                 óX   — | j                  | j                  j                  ||«      «      S ©z'Convert Python's ``int`` to ``dtype``. ©r1   r$   rk   rf   s      r   re   zFiniteField.from_ZZ
  ó"   € à�x‰x˜Ÿ™×-Ñ-¨a°Ó4Ó5Ð5r8   c                 óX   — | j                  | j                  j                  ||«      «      S rn   ro   rf   s      r   rk   zFiniteField.from_ZZ_python  rp   r8   c                 óX   — |j                   dk(  r| j                  |j                  «      S y©z,Convert Python's ``Fraction`` to ``dtype``. r/   N©Údenominatorrk   Ú	numeratorrf   s      r   Úfrom_QQzFiniteField.from_QQ  ó(   € à�=‰=˜AÒØ×$Ñ$ Q§[¡[Ó1Ð1ð r8   c                 óX   — |j                   dk(  r| j                  |j                  «      S yrs   rt   rf   s      r   Úfrom_QQ_pythonzFiniteField.from_QQ_python  rx   r8   c                 ó€   — | j                  | j                  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©E°2·6±6Ó:Ó;Ð;r8   c                 óX   — | j                  | j                  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Ó3Ð3r8   c                 óX   — |j                   dk(  r| j                  |j                  «      S y)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                 óŠ   — |j                  |«      \  }}|dk(  r*| j                  | j                  j                  |«      «      S y)z'Convert mpmath's ``mpf`` to ``dtype``. r/   N)Úto_rationalr1   r$   )rg   rQ   rh   ÚpÚqs        r   Úfrom_RealFieldzFiniteField.from_RealField)  s;   € à�~‰~˜aÓ ‰ˆˆ1à�Š6Ø—8‘8˜BŸF™FŸL™L¨›OÓ,Ð,ð r8   c                 ó°   — | j                   | j                  | fD �cg c]  }t        |«      ‘Œ }}t        || j                  | j
                  «       S c c}w )z7Returns True if ``a`` is a quadratic residue modulo p. )r3   r2   rU   r
   r   r$   )r&   rQ   r   Úpolys       r   Ú	is_squarezFiniteField.is_square0  sK   € ð "&§¡¨4¯9©9°q°bÐ 9Ö:˜1”�A•Ð:ˆÐ:Ü# D¨$¯(©(°D·H±HÓ=Ð=Ð=ùò ;s   �Ac                 óZ  — | j                   dk(  s|dk(  r|S | j                  | j                  | fD �cg c]  }t        |«      ‘Œ }}t	        || j                   | j
                  «      D ]<  }t        |«      dk(  sŒ|d   | j                   dz  k  sŒ(| j                  |d   «      c S  yc c}w )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   r/   N)r   r3   r2   rU   r	   r$   Úlenr1   )r&   rQ   r   rˆ   Úfactors        r   ÚexsqrtzFiniteField.exsqrt6  sž   € ð �8‰8�qŠ=˜A šFØˆHà!%§¡¨4¯9©9°q°bÐ 9Ö:˜1”�A•Ð:ˆÐ:Ü# D¨$¯(©(°D·H±HÓ=ò 	-ˆFÜ�6‹{˜aÓ F¨1¡I°·±¸Q±Ó$>Ø—z‘z &¨¡)Ó,Ò,ð	-ð ùò	 ;s   ³B()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ðp €CØ€Eà!Ð!€N�UØ€Là€NØ€Oà
€CØ
€Có#ð ñó ðò#òOò<ò
òò,òDòòòòòó8ó?ó6ó6ó2ó
2ó
<ó4ó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ã å ,Ý 8å )Ý +å DÝ 9ß CÝ 1Ý "Ý 8ð �7ÒØ%�Ðð �7ÒÛð ×*Ñ*×0Ñ0°Ó5Ð€FˆF�QÙˆF‹‘S˜“[Ð! FÒ*Ø‰à€Eò,<ð^ Ù˜X vÐ.Ô/ôr�%˜ó ró 0ó ðrðj Ð €�Rr8   