ó
    Š*£hž)  ã                   ór  • S r SSKrSSKJr  SSKJr  SSKJr  SSKJ	r	  SSK
Jr  SSKJr  SS	KJrJr  SS
KJr  SSKJr  SSKJr  \S:X  a  S/r\S:X  a9  SSKr\R2                  R5                  S5      trrr\" \5      \" \5      4S:  a  SrOSrS rS r S r!\\" SS/S9 " S S\	\5      5       5       r"\"=r#r$g)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                 óÒ   ^ ^^^• [         R                  mT" T 5      m [        R                  m[        R                  m T" ST 5        UU U4S jnU U4S jnX4$ ! [
         a     gf = f)Nr   )NNc                 óV   >•  T" U T5      $ ! [          a    T" T" U 5      T5      s $ f = f©N©Ú	TypeError)ÚxÚindexÚmodÚnmods    €€€Ú\/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/polys/domains/finitefield.pyÚctxÚ&_modular_int_factory_nmod.<locals>.ctx/   s4   ø€ ð	'Ù˜˜3“<ÐøÜó 	'Ù™˜a› #Ó&Ò&ð	'ús   ƒ Œ(§(c                 ó   >• T" U T5      $ r   © )Úcsr   Ú	nmod_polys    €€r   Úpoly_ctxÚ+_modular_int_factory_nmod.<locals>.poly_ctx5   s   ø€ Ù˜˜SÓ!Ð!ó    )Úoperatorr   r   r   r!   ÚOverflowError)r   r   r"   r   r   r!   s   `  @@@r   Ú_modular_int_factory_nmodr'   "   s]   û€ ä�N‰N€EÙ
�‹*€CÜ�:‰:€DÜ—‘€IðÙˆQ�Œ÷'ö"ð ˆ=Ðøô ó Ùðús   ¾	A Á
A&Á%A&c                 óÄ   ^^^^• [         R                  m[        R                  " U 5      m[        R                  " U 5      m[        R
                  mUU4S jnUU4S jnX4$ )Nc                 óR   >•  T" U 5      $ ! [          a    T" T" U 5      5      s $ f = fr   r   )r   Úfctxr   s    €€r   r   Ú*_modular_int_factory_fmpz_mod.<locals>.ctxA   s.   ø€ ð	"Ù˜“7ˆNøÜó 	"á™˜a›“>Ò!ð	"ús   ƒ ‹&¥&c                 ó   >• T" U T5      $ r   r   )r    Ú	fctx_polyÚfmpz_mod_polys    €€r   r"   Ú/_modular_int_factory_fmpz_mod.<locals>.poly_ctxH   s   ø€ Ù˜R Ó+Ð+r$   )r%   r   r   Úfmpz_mod_ctxÚfmpz_mod_poly_ctxr.   )r   r   r"   r*   r-   r.   r   s      @@@@r   Ú_modular_int_factory_fmpz_modr2   ;   sK   û€ Ü�N‰N€EÜ×Ò˜cÓ"€DÜ×'Ò'¨Ó,€IÜ×'Ñ'€Mö"ö,ð ˆ=Ðr$   c                 ó  •  UR                  U 5      n Su  pEn[        b4  U R	                  5       (       a  Sn[        U 5      u  pEUc  [        U 5      u  pEUc  [        XX#5      nS nXEU4$ ! [         a    [        SU -  5      ef = f)Nz"modulus must be an integer, got %s)NNFT)Úconvertr   Ú
ValueErrorr   Úis_primer'   r2   r   )r   ÚdomÚ	symmetricÚselfr   r"   Úis_flints          r   Ú_modular_int_factoryr;   N   sŸ   € ðEØ�k‰k˜#Óˆð 0Ñ€C�8ô Ñ˜SŸ\™\Ÿ^™^àˆô 2°#Ó6‰ˆà‰;ä9¸#Ó>‰MˆCà
�{ô $ C¨iÓ>ˆØˆà˜(Ð"Ð"øô/ ó EÜÐ=ÀÑCÓDÐDðEús   ‚A( Á(BÚpythonÚgmpy)Úmodulesc                   ó  • \ rS rSrSrSrSrS=rrSr	Sr
SrSrSrS#S jr\S 5       r\S	 5       rS
 rS rS rS rS rS rS rS rS rS rS rS rS$S jrS$S jrS$S jr S$S jr!S$S jr"S$S jr#S$S jr$S$S jr%S$S jr&S r'S  r(S! r)S"r*g)%r   él   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                 ó.  • SSK Jn  UnUS::  a  [        SU-  5      e[        XX 5      u  pVnXPl        X`l        Xpl        U R	                  S5      U l        U R	                  S5      U l        X@l	        Xl
        X l        [        U R                  5      U l        g )Nr   )ÚZZz*modulus must be a positive integer, got %sé   )Úsympy.polys.domainsrC   r5   r;   ÚdtypeÚ	_poly_ctxÚ	_is_flintÚzeroÚoner7   r   ÚsymÚtypeÚ_tp)r9   r   r8   rC   r7   r   r"   r:   s           r   Ú__init__ÚFiniteField.__init__Ó   s~   € Ý*Øˆà�!‹8ÜÐIÈCÑOÓPÐPä"6°sÀÓ"QÑˆ�xàŒ
Ø!ŒØ!Œà—J‘J˜q“MˆŒ	Ø—:‘:˜a“=ˆŒØŒØŒØŒÜ˜Ÿ	™	“?ˆ�r$   c                 ó   • U R                   $ r   )rM   ©r9   s    r   ÚtpÚFiniteField.tpç   ó   € à�x‰xˆr$   c                 ód   • [        U SS 5      nUc  SSKJn  U" U R                  5      =U l        nU$ )NÚ	_is_fieldr   )Úisprime)ÚgetattrÚsympy.ntheory.primetestrW   r   rV   )r9   Úis_fieldrW   s      r   Úis_FieldÚFiniteField.is_Fieldë   s3   € ä˜4 ¨dÓ3ˆØÑÝ7Ù(/°·±Ó(9Ð9ˆDŒN˜XØˆr$   c                 ó    • SU R                   -  $ )NzGF(%s)©r   rQ   s    r   Ú__str__ÚFiniteField.__str__ó   s   € Ø˜$Ÿ(™(Ñ"Ð"r$   c                 ó„   • [        U R                  R                  U R                  U R                  U R
                  45      $ r   )ÚhashÚ	__class__Ú__name__rF   r   r7   rQ   s    r   Ú__hash__ÚFiniteField.__hash__ö   s,   € Ü�T—^‘^×,Ñ,¨d¯j©j¸$¿(¹(ÀDÇHÁHÐMÓNÐNr$   c                 ó¢   • [        U[        5      =(       a9    U R                  UR                  :H  =(       a    U R                  UR                  :H  $ )z0Returns ``True`` if two domains are equivalent. )Ú
isinstancer   r   r7   )r9   Úothers     r   Ú__eq__ÚFiniteField.__eq__ù   s;   € ä˜%¤Ó-÷ <Ø�H‰H˜Ÿ	™	Ñ!÷<Ø&*§h¡h°%·)±)Ñ&;ð	<r$   c                 ó   • U R                   $ )z*Return the characteristic of this domain. r^   rQ   s    r   ÚcharacteristicÚFiniteField.characteristicþ   rT   r$   c                 ó   • U $ )z*Returns a field associated with ``self``. r   rQ   s    r   Ú	get_fieldÚFiniteField.get_field  s   € àˆr$   c                 ó6   • [        U R                  U5      5      $ )z!Convert ``a`` to a SymPy object. )r   Úto_int©r9   Úas     r   Úto_sympyÚFiniteField.to_sympy  s   € ä˜DŸK™K¨›NÓ+Ð+r$   c                 ó,  • UR                   (       a3  U R                  U R                  R                  [        U5      5      5      $ [	        U5      (       a3  U R                  U R                  R                  [        U5      5      5      $ [        SU-  5      e)z0Convert SymPy's Integer to SymPy's ``Integer``. zexpected an integer, got %s)Ú
is_IntegerrF   r7   Úintr   r   rt   s     r   Ú
from_sympyÚFiniteField.from_sympy
  sc   € à�<�<Ø—:‘:˜dŸh™hŸn™n¬S°«VÓ4Ó5Ð5Ü˜�]‰]Ø—:‘:˜dŸh™hŸn™n¬S°«VÓ4Ó5Ð5ä Ð!>ÀÑ!BÓCÐCr$   c                 ó~   • [        U5      nU R                  (       a   X R                  S-  :”  a  X R                  -  nU$ )z,Convert ``val`` to a Python ``int`` object. é   )rz   rK   r   )r9   ru   Úavals      r   rs   ÚFiniteField.to_int  s0   € ä�1‹vˆØ�8�8˜Ÿx™x¨1™}Ó,Ø—H‘HÑˆDØˆr$   c                 ó   • [        U5      $ )z#Returns True if ``a`` is positive. )Úboolrt   s     r   Úis_positiveÚFiniteField.is_positive  s   € ä�A‹wˆr$   c                 ó   • g)z'Returns True if ``a`` is non-negative. Tr   rt   s     r   Úis_nonnegativeÚFiniteField.is_nonnegative  s   € àr$   c                 ó   • g)z#Returns True if ``a`` is negative. Fr   rt   s     r   Úis_negativeÚFiniteField.is_negative"  s   € àr$   c                 ó   • U(       + $ )z'Returns True if ``a`` is non-positive. r   rt   s     r   Úis_nonpositiveÚFiniteField.is_nonpositive&  s	   € àŒuˆr$   c                 ó~   • U R                  U R                  R                  [        U5      UR                  5      5      $ ©z.Convert ``ModularInteger(int)`` to ``dtype``. )rF   r7   Úfrom_ZZrz   ©ÚK1ru   ÚK0s      r   Úfrom_FFÚFiniteField.from_FF*  s(   € à�x‰x˜Ÿ™Ÿ™¤s¨1£v¨r¯v©vÓ6Ó7Ð7r$   c                 ó~   • U R                  U R                  R                  [        U5      UR                  5      5      $ r�   )rF   r7   Úfrom_ZZ_pythonrz   r‘   s      r   Úfrom_FF_pythonÚFiniteField.from_FF_python.  s*   € à�x‰x˜Ÿ™×-Ñ-¬c°!«f°b·f±fÓ=Ó>Ð>r$   c                 óV   • U R                  U R                  R                  X5      5      $ ©z'Convert Python's ``int`` to ``dtype``. ©rF   r7   r—   r‘   s      r   r�   ÚFiniteField.from_ZZ2  ó    € à�x‰x˜Ÿ™×-Ñ-¨aÓ4Ó5Ð5r$   c                 óV   • U R                  U R                  R                  X5      5      $ r›   rœ   r‘   s      r   r—   ÚFiniteField.from_ZZ_python6  rž   r$   c                 óZ   • UR                   S:X  a  U R                  UR                  5      $ g©z,Convert Python's ``Fraction`` to ``dtype``. rD   N©Údenominatorr—   Ú	numeratorr‘   s      r   Úfrom_QQÚFiniteField.from_QQ:  ó(   € à�=‰=˜AÓØ×$Ñ$ Q§[¡[Ó1Ð1ð r$   c                 óZ   • UR                   S:X  a  U R                  UR                  5      $ gr¢   r£   r‘   s      r   Úfrom_QQ_pythonÚFiniteField.from_QQ_python?  r¨   r$   c                 ó€   • U R                  U R                  R                  UR                  UR                  5      5      $ )z.Convert ``ModularInteger(mpz)`` to ``dtype``. )rF   r7   Úfrom_ZZ_gmpyÚvalr‘   s      r   Úfrom_FF_gmpyÚFiniteField.from_FF_gmpyD  s*   € à�x‰x˜Ÿ™×+Ñ+¨A¯E©E°2·6±6Ó:Ó;Ð;r$   c                 óV   • U R                  U R                  R                  X5      5      $ )z%Convert GMPY's ``mpz`` to ``dtype``. )rF   r7   r­   r‘   s      r   r­   ÚFiniteField.from_ZZ_gmpyH  s    € à�x‰x˜Ÿ™×+Ñ+¨AÓ2Ó3Ð3r$   c                 óZ   • UR                   S:X  a  U R                  UR                  5      $ g)z%Convert GMPY's ``mpq`` to ``dtype``. rD   N)r¤   r­   r¥   r‘   s      r   Úfrom_QQ_gmpyÚFiniteField.from_QQ_gmpyL  s&   € à�=‰=˜AÓØ—?‘? 1§;¡;Ó/Ð/ð r$   c                 óŠ   • UR                  U5      u  p4US:X  a*  U R                  U R                  R                  U5      5      $ g)z'Convert mpmath's ``mpf`` to ``dtype``. rD   N)Úto_rationalrF   r7   )r’   ru   r“   ÚpÚqs        r   Úfrom_RealFieldÚFiniteField.from_RealFieldQ  s9   € à�~‰~˜aÓ ‰ˆà�‹6Ø—8‘8˜BŸF™FŸL™L¨›OÓ,Ð,ð r$   c                 ó¼   • U R                   U R                  U* 4 Vs/ s H  n[        U5      PM     nn[        X0R                  U R
                  5      (       + $ s  snf )z7Returns True if ``a`` is a quadratic residue modulo p. )rJ   rI   rz   r
   r   r7   )r9   ru   r   Úpolys       r   Ú	is_squareÚFiniteField.is_squareX  sL   € ð "&§¡¨4¯9©9°q°bÑ 9Ó:Ò 9˜1”�A–Ñ 9ˆÐ:Ü# D¯(©(°D·H±HÓ=Ô=Ð=ùò ;s   �Ac                 ól  • U R                   S:X  d  US:X  a  U$ U R                  U R                  U* 4 Vs/ s H  n[        U5      PM     nn[	        X0R                   U R
                  5       H@  n[        U5      S:X  d  M  US   U R                   S-  ::  d  M,  U R                  US   5      s  $    gs  snf )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``.
r~   r   rD   N)r   rJ   rI   rz   r	   r7   ÚlenrF   )r9   ru   r   r½   Úfactors        r   ÚexsqrtÚFiniteField.exsqrt^  sš   € ð �8‰8�q‹=˜A ›FØˆHà!%§¡¨4¯9©9°q°bÑ 9Ó:Ò 9˜1”�A–Ñ 9ˆÐ:Ü# D¯(©(°D·H±HÖ=ˆFÜ�6‹{˜aÕ F¨1¡I°·±¸Q±Õ$>Ø—z‘z &¨¡)Ó,Ò,ñ >ð ùò	 ;s   µB1)
rV   rH   rG   rM   r7   rF   r   rJ   rK   rI   )Tr   )+rd   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__ÚrepÚaliasÚis_FiniteFieldÚis_FFÚis_NumericalÚhas_assoc_RingÚhas_assoc_Fieldr7   r   rN   ÚpropertyrR   r[   r_   re   rj   rm   rp   rv   r{   rs   rƒ   r†   r‰   rŒ   r”   r˜   r�   r—   r¦   rª   r¯   r­   r´   rº   r¾   rÃ   Ú__static_attributes__r   r$   r   r   r   l   sß   † ñVðp €CØ€Eà!Ð!€N�UØ€Là€NØ€Oà
€CØ
€Cô#ð( ñó ðð ñó ðò#òOò<ò
òò,òDòòòòòô8ô?ô6ô6ô2ô
2ô
<ô4ô0ò
-ò>õr$   )%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Ú_rz   r'   r2   r;   r   rA   ÚGFr   r$   r   Ú<module>rã      sÕ   ðÙ 4ã å ,Ý 8å )Ý +å DÝ 9ß CÝ 1Ý "Ý 8ð �7ÓØ%�Ðð �7ÓÛð ×*Ñ*×0Ñ0°Ó5Ð€FˆF�QÙˆF‹‘S˜“[Ð! FÓ*Øˆøà€Eòò2ò&#ð< Ù˜X vÐ.Ñ/ô�%˜ó ó 0ó ððD Ð €�Rr$   