+
    -åûj’Ÿ  ã                  óÎ   € R t ^ RIHt ^ RIHt ^ RIHt ^ RIHtH	t	 ^ RI
Ht ^ RIHt ^ RIHt ^ RIHt ^ R	IHtHtHt ^ R
IHtHt ^ RIHt ^ RIHt ] ! R R4      4       tR.tR# )z)Implementation of :class:`Domain` class. )Úannotations)ÚAny)ÚAlgebraicNumber)ÚBasicÚsympify)Úordered)ÚGROUND_TYPES)ÚDomainElement)Úlex)ÚUnificationFailedÚCoercionFailedÚDomainError)Ú_unify_gensÚ_not_a_coeff)Úpublic)Úis_sequencec                  óF  € ] tR t^t$ RtRtR]R&    RtR]R&    RtR]R&    Rt	 Rt
 Rt Rt R;ttR;ttR;ttR;ttR;ttR;ttR;ttR;ttR;ttR;tt R;t!t"R;t#t$Rt%R	t&Rt'Rt(Rt)Rt* Rt+Rt,R
]R&   Rt-R
]R&   R t.R t/R t0R t1R t2]3R 4       t4R t5R t6R t7RfR lt8R t9R t:R t;R t<R t=R t>R t?R t@R tAR  tBR! tCR" tDR# tER$ tFR% tGR& tHR' tIR( tJR) tKR* tLR+ tMR, tNR- tOR. tPRfR/ ltQR0 tRR1 tSR2 tTR3 tUR4 tVR5 tWR6 tXR7]Y/R8 ltZR7]Y/R9 lt[R: t\R; t]RR/R< lt^RgR= lt_RhR> lt`R? taR@ tbRA tcRB tdRC teRD tfRE tgRF thRG tiRH tjRI tkRJ tlRK tmRL tnRM toRN tpRO tqRP trRQ tsRR ttRS tuRT tvRU twRV txRW tyRX tzRY t{RZ t|R[ t}R\ t~R] tR^ t€R_ t�RfR` lt‚]‚tƒRa t„Rb t…RfRc lt†Rd t‡RetˆR# )iÚDomaina*  Superclass for all domains in the polys domains system.

See :ref:`polys-domainsintro` for an introductory explanation of the
domains system.

The :py:class:`~.Domain` class is an abstract base class for all of the
concrete domain types. There are many different :py:class:`~.Domain`
subclasses each of which has an associated ``dtype`` which is a class
representing the elements of the domain. The coefficients of a
:py:class:`~.Poly` are elements of a domain which must be a subclass of
:py:class:`~.Domain`.

Examples
========

The most common example domains are the integers :ref:`ZZ` and the
rationals :ref:`QQ`.

>>> from sympy import Poly, symbols, Domain
>>> x, y = symbols('x, y')
>>> p = Poly(x**2 + y)
>>> p
Poly(x**2 + y, x, y, domain='ZZ')
>>> p.domain
ZZ
>>> isinstance(p.domain, Domain)
True
>>> Poly(x**2 + y/2)
Poly(x**2 + 1/2*y, x, y, domain='QQ')

The domains can be used directly in which case the domain object e.g.
(:ref:`ZZ` or :ref:`QQ`) can be used as a constructor for elements of
``dtype``.

>>> from sympy import ZZ, QQ
>>> ZZ(2)
2
>>> ZZ.dtype  # doctest: +SKIP
<class 'int'>
>>> type(ZZ(2))  # doctest: +SKIP
<class 'int'>
>>> QQ(1, 2)
1/2
>>> type(QQ(1, 2))  # doctest: +SKIP
<class 'sympy.polys.domains.pythonrational.PythonRational'>

The corresponding domain elements can be used with the arithmetic
operations ``+,-,*,**`` and depending on the domain some combination of
``/,//,%`` might be usable. For example in :ref:`ZZ` both ``//`` (floor
division) and ``%`` (modulo division) can be used but ``/`` (true
division) cannot. Since :ref:`QQ` is a :py:class:`~.Field` its elements
can be used with ``/`` but ``//`` and ``%`` should not be used. Some
domains have a :py:meth:`~.Domain.gcd` method.

>>> ZZ(2) + ZZ(3)
5
>>> ZZ(5) // ZZ(2)
2
>>> ZZ(5) % ZZ(2)
1
>>> QQ(1, 2) / QQ(2, 3)
3/4
>>> ZZ.gcd(ZZ(4), ZZ(2))
2
>>> QQ.gcd(QQ(2,7), QQ(5,3))
1/21
>>> ZZ.is_Field
False
>>> QQ.is_Field
True

There are also many other domains including:

    1. :ref:`GF(p)` for finite fields of prime order.
    2. :ref:`RR` for real (floating point) numbers.
    3. :ref:`CC` for complex (floating point) numbers.
    4. :ref:`QQ(a)` for algebraic number fields.
    5. :ref:`K[x]` for polynomial rings.
    6. :ref:`K(x)` for rational function fields.
    7. :ref:`EX` for arbitrary expressions.

Each domain is represented by a domain object and also an implementation
class (``dtype``) for the elements of the domain. For example the
:ref:`K[x]` domains are represented by a domain object which is an
instance of :py:class:`~.PolynomialRing` and the elements are always
instances of :py:class:`~.PolyElement`. The implementation class
represents particular types of mathematical expressions in a way that is
more efficient than a normal SymPy expression which is of type
:py:class:`~.Expr`. The domain methods :py:meth:`~.Domain.from_sympy` and
:py:meth:`~.Domain.to_sympy` are used to convert from :py:class:`~.Expr`
to a domain element and vice versa.

>>> from sympy import Symbol, ZZ, Expr
>>> x = Symbol('x')
>>> K = ZZ[x]           # polynomial ring domain
>>> K
ZZ[x]
>>> type(K)             # class of the domain
<class 'sympy.polys.domains.polynomialring.PolynomialRing'>
>>> K.dtype             # doctest: +SKIP
<class 'sympy.polys.rings.PolyElement'>
>>> p_expr = x**2 + 1   # Expr
>>> p_expr
x**2 + 1
>>> type(p_expr)
<class 'sympy.core.add.Add'>
>>> isinstance(p_expr, Expr)
True
>>> p_domain = K.from_sympy(p_expr)
>>> p_domain            # domain element
x**2 + 1
>>> type(p_domain)
<class 'sympy.polys.rings.PolyElement'>
>>> K.to_sympy(p_domain) == p_expr
True

The :py:meth:`~.Domain.convert_from` method is used to convert domain
elements from one domain to another.

>>> from sympy import ZZ, QQ
>>> ez = ZZ(2)
>>> eq = QQ.convert_from(ez, ZZ)
>>> type(ez)  # doctest: +SKIP
<class 'int'>
>>> type(eq)  # doctest: +SKIP
<class 'sympy.polys.domains.pythonrational.PythonRational'>

Elements from different domains should not be mixed in arithmetic or other
operations: they should be converted to a common domain first.  The domain
method :py:meth:`~.Domain.unify` is used to find a domain that can
represent all the elements of two given domains.

>>> from sympy import ZZ, QQ, symbols
>>> x, y = symbols('x, y')
>>> ZZ.unify(QQ)
QQ
>>> ZZ[x].unify(QQ)
QQ[x]
>>> ZZ[x].unify(QQ[y])
QQ[x,y]

If a domain is a :py:class:`~.Ring` then is might have an associated
:py:class:`~.Field` and vice versa. The :py:meth:`~.Domain.get_field` and
:py:meth:`~.Domain.get_ring` methods will find or create the associated
domain.

>>> from sympy import ZZ, QQ, Symbol
>>> x = Symbol('x')
>>> ZZ.has_assoc_Field
True
>>> ZZ.get_field()
QQ
>>> QQ.has_assoc_Ring
True
>>> QQ.get_ring()
ZZ
>>> K = QQ[x]
>>> K
QQ[x]
>>> K.get_field()
QQ(x)

See also
========

DomainElement: abstract base class for domain elements
construct_domain: construct a minimal domain for some expressions

Nztype | NoneÚdtyper   ÚzeroÚoneFTz
str | NoneÚrepÚaliasc                	ó   € \         h©N©ÚNotImplementedError©Úselfs   &ÚVC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\sympy\polys\domains\domain.pyÚ__init__ÚDomain.__init__g  s   € Ü!Ð!ó    c                	ó   € V P                   # r   )r   r   s   &r   Ú__str__ÚDomain.__str__j  s   € Ø�x‰xˆr"   c                	ó   € \        V 4      # r   )Ústrr   s   &r   Ú__repr__ÚDomain.__repr__m  s   € Ü�4‹yÐr"   c                	óX   € \        V P                  P                  V P                  34      # r   )ÚhashÚ	__class__Ú__name__r   r   s   &r   Ú__hash__ÚDomain.__hash__p  s    € Ü�T—^‘^×,Ñ,¨d¯j©jÐ9Ó:Ð:r"   c                	ó"   € V P                   ! V!  # r   ©r   ©r   Úargss   &*r   ÚnewÚ
Domain.news  ó   € Ø�zŠz˜4Ñ Ð r"   c                ó   € V P                   # )z#Alias for :py:attr:`~.Domain.dtype`r1   r   s   &r   ÚtpÚ	Domain.tpv  s   € ð �z‰zÐr"   c                ó"   € V P                   ! V!  # )z7Construct an element of ``self`` domain from ``args``. )r4   r2   s   &*r   Ú__call__ÚDomain.__call__{  s   € à�xŠx˜‰Ðr"   c                	ó"   € V P                   ! V!  # r   r1   r2   s   &*r   ÚnormalÚDomain.normal  r6   r"   c           
     ó  € VP                   e   RVP                   ,           pMRVP                  P                  ,           p\        W4      pVe   V! W4      pVe   V# \	        RV: R\        V4      : RV: RV : 24      h)z=Convert ``element`` to ``self.dtype`` given the base domain. Úfrom_úCannot convert ú	 of type z from ú to )r   r,   r-   Úgetattrr   Útype)r   ÚelementÚbaseÚmethodÚ_convertÚresults   &&&   r   Úconvert_fromÚDomain.convert_from‚  sp   € à�:‰:Ò!Ø˜tŸz™zÕ)‰Fà˜tŸ~™~×6Ñ6Õ6ˆFä˜4Ó(ˆàÒÙ˜gÓ,ˆFàÒ!Ø�åËWÔVZÐ[bÖVcÓeiÒkoÐpÓqÐqr"   c                ó˜  € Ve5   \        V4      '       d   \        RV,          4      hV P                  W4      # V P                  V4      '       d   V# \        V4      '       d   \        RV,          4      h^ RIHpHpHpHp VP                  V4      '       d   V P                  W4      # \        V\        4      '       d   V P                  V! V4      V4      # \        R8w  dY   \        WP                  4      '       d   V P                  W4      # \        WP                  4      '       d   V P                  W4      # \        V\        4      '       d    V! 4       pV P                  V! V4      V4      # \        V\        4      '       d    V! 4       pV P                  V! V4      V4      # \        V4      P                   R8X  d    V! 4       pV P                  V! V4      V4      # \        V4      P                   R8X  d    V! 4       pV P                  V! V4      V4      # \        V\"        4      '       d    V P                  WP%                  4       4      # V P&                  '       d3   \)        VRR4      '       d    V P+                  VP-                  4       4      # \        V\.        4      '       d    V P1                  V4      # \7        V4      '       g7    \9        VRR	7      p\        V\.        4      '       d   V P1                  V4      #  \        R
V: R\        V4      : RV : 24      h  \2        \4        3 d     L3i ; i  \2        \4        3 d     LJi ; i)z'Convert ``element`` to ``self.dtype``. z%s is not in any domain)ÚZZÚQQÚ	RealFieldÚComplexFieldÚpythonÚmpfÚmpcÚ	is_groundFT)ÚstrictrB   rC   rD   )r   r   rL   Úof_typeÚsympy.polys.domainsrO   rP   rQ   rR   Ú
isinstanceÚintr   r8   ÚfloatÚcomplexrF   r-   r	   ÚparentÚis_NumericalrE   ÚconvertÚLCr   Ú
from_sympyÚ	TypeErrorÚ
ValueErrorr   r   )r   rG   rH   rO   rP   rQ   rR   r^   s   &&&     r   r`   ÚDomain.convert“  s°  € ð ÒÜ˜G×$Ò$Ü$Ð%>ÀÕ%HÓIÐIØ×$Ñ$ WÓ3Ð3à�<‰<˜× Ò ØˆNä˜× Ò Ü Ð!:¸WÕ!DÓEÐEçGÓGà�:‰:�g×ÒØ×$Ñ$ WÓ1Ð1ä�gœs×#Ò#Ø×$Ñ$¡R¨£[°"Ó5Ð5ä˜8Ô#Ü˜'§5¡5×)Ò)Ø×(Ñ(¨Ó5Ð5Ü˜'§5¡5×)Ò)Ø×(Ñ(¨Ó5Ð5ä�gœu×%Ò%Ù“[ˆFØ×$Ñ$¡V¨G£_°fÓ=Ð=ä�gœw×'Ò'Ù!“^ˆFØ×$Ñ$¡V¨G£_°fÓ=Ð=ä�‹=×!Ñ! UÔ*Ù“[ˆFØ×$Ñ$¡V¨G£_°fÓ=Ð=ä�‹=×!Ñ! UÔ*Ù!“^ˆFØ×$Ñ$¡V¨G£_°fÓ=Ð=ä�gœ}×-Ò-Ø×$Ñ$ W¯n©nÓ.>Ó?Ð?ð ××Ð¤¨°+¸u×!EÒ!EØ—<‘< §
¡
£Ó-Ð-ä�gœu×%Ò%ðØ—‘ wÓ/Ð/ô ˜w×'Ò'ðÜ% g°dÔ;�GÜ! '¬5×1Ò1Ø#Ÿ™¨wÓ7Ð7ð 2õ
 ÃWÌdÐSZÎmÒ]aÐbÓcÐcøô œzÐ*ô Ùðûô "¤:Ð.ô Ùðús$   Ê&L Ë	3L5 ÌL2Ì1L2Ì5M	ÍM	c                ó,   € \        WP                  4      # )z%Check if ``a`` is of type ``dtype``. )rZ   r8   )r   rG   s   &&r   rX   ÚDomain.of_typeÖ  s   € ä˜'§7¡7Ó+Ð+r"   c                ó|   €  \        V4      '       d   \        hV P                  V4       R#   \         d     R# i ; i)z'Check if ``a`` belongs to this domain. FT)r   r   r`   ©r   Úas   &&r   Ú__contains__ÚDomain.__contains__Ú  s:   € ð	Ü˜A�ŠÜ$Ð$Ø�L‰L˜ŒOñ øô ô 	Úð	ús   ‚(, ¬;º;c                ó   € \         h)aÆ  Convert domain element *a* to a SymPy expression (Expr).

Explanation
===========

Convert a :py:class:`~.Domain` element *a* to :py:class:`~.Expr`. Most
public SymPy functions work with objects of type :py:class:`~.Expr`.
The elements of a :py:class:`~.Domain` have a different internal
representation. It is not possible to mix domain elements with
:py:class:`~.Expr` so each domain has :py:meth:`~.Domain.to_sympy` and
:py:meth:`~.Domain.from_sympy` methods to convert its domain elements
to and from :py:class:`~.Expr`.

Parameters
==========

a: domain element
    An element of this :py:class:`~.Domain`.

Returns
=======

expr: Expr
    A normal SymPy expression of type :py:class:`~.Expr`.

Examples
========

Construct an element of the :ref:`QQ` domain and then convert it to
:py:class:`~.Expr`.

>>> from sympy import QQ, Expr
>>> q_domain = QQ(2)
>>> q_domain
2
>>> q_expr = QQ.to_sympy(q_domain)
>>> q_expr
2

Although the printed forms look similar these objects are not of the
same type.

>>> isinstance(q_domain, Expr)
False
>>> isinstance(q_expr, Expr)
True

Construct an element of :ref:`K[x]` and convert to
:py:class:`~.Expr`.

>>> from sympy import Symbol
>>> x = Symbol('x')
>>> K = QQ[x]
>>> x_domain = K.gens[0]  # generator x as a domain element
>>> p_domain = x_domain**2/3 + 1
>>> p_domain
1/3*x**2 + 1
>>> p_expr = K.to_sympy(p_domain)
>>> p_expr
x**2/3 + 1

The :py:meth:`~.Domain.from_sympy` method is used for the opposite
conversion from a normal SymPy expression to a domain element.

>>> p_domain == p_expr
False
>>> K.from_sympy(p_expr) == p_domain
True
>>> K.to_sympy(p_domain) == p_expr
True
>>> K.from_sympy(K.to_sympy(p_domain)) == p_domain
True
>>> K.to_sympy(K.from_sympy(p_expr)) == p_expr
True

The :py:meth:`~.Domain.from_sympy` method makes it easier to construct
domain elements interactively.

>>> from sympy import Symbol
>>> x = Symbol('x')
>>> K = QQ[x]
>>> K.from_sympy(x**2/3 + 1)
1/3*x**2 + 1

See also
========

from_sympy
convert_from
r   ri   s   &&r   Úto_sympyÚDomain.to_sympyå  s   € ôv "Ð!r"   c                ó   € \         h)aj  Convert a SymPy expression to an element of this domain.

Explanation
===========

See :py:meth:`~.Domain.to_sympy` for explanation and examples.

Parameters
==========

expr: Expr
    A normal SymPy expression of type :py:class:`~.Expr`.

Returns
=======

a: domain element
    An element of this :py:class:`~.Domain`.

See also
========

to_sympy
convert_from
r   ri   s   &&r   rb   ÚDomain.from_sympyB  s
   € ô4 "Ð!r"   c                	ó.   € \        WP                  R 7      # ))Ústart)Úsumr   r2   s   &&r   rt   Ú
Domain.sum^  s   € Ü�4Ÿy™yÔ)Ð)r"   c                ó   € R# ©z.Convert ``ModularInteger(int)`` to ``dtype``. N© ©ÚK1rj   ÚK0s   &&&r   Úfrom_FFÚDomain.from_FFa  ó   € ár"   c                ó   € R# rw   rx   ry   s   &&&r   Úfrom_FF_pythonÚDomain.from_FF_pythone  r~   r"   c                ó   € R# )z.Convert a Python ``int`` object to ``dtype``. Nrx   ry   s   &&&r   Úfrom_ZZ_pythonÚDomain.from_ZZ_pythoni  r~   r"   c                ó   € R# )z3Convert a Python ``Fraction`` object to ``dtype``. Nrx   ry   s   &&&r   Úfrom_QQ_pythonÚDomain.from_QQ_pythonm  r~   r"   c                ó   € R# )z.Convert ``ModularInteger(mpz)`` to ``dtype``. Nrx   ry   s   &&&r   Úfrom_FF_gmpyÚDomain.from_FF_gmpyq  r~   r"   c                ó   € R# )z,Convert a GMPY ``mpz`` object to ``dtype``. Nrx   ry   s   &&&r   Úfrom_ZZ_gmpyÚDomain.from_ZZ_gmpyu  r~   r"   c                ó   € R# )z,Convert a GMPY ``mpq`` object to ``dtype``. Nrx   ry   s   &&&r   Úfrom_QQ_gmpyÚDomain.from_QQ_gmpyy  r~   r"   c                ó   € R# )z,Convert a real element object to ``dtype``. Nrx   ry   s   &&&r   Úfrom_RealFieldÚDomain.from_RealField}  r~   r"   c                ó   € R# )z(Convert a complex element to ``dtype``. Nrx   ry   s   &&&r   Úfrom_ComplexFieldÚDomain.from_ComplexField�  r~   r"   c                ó   € R# )z*Convert an algebraic number to ``dtype``. Nrx   ry   s   &&&r   Úfrom_AlgebraicFieldÚDomain.from_AlgebraicField…  r~   r"   c                óv   € VP                   '       d'   V P                  VP                  VP                  4      # R# ©z#Convert a polynomial to ``dtype``. N)rV   r`   ra   Údomry   s   &&&r   Úfrom_PolynomialRingÚDomain.from_PolynomialRing‰  s)   € à�;�;ˆ;Ø—:‘:˜aŸd™d B§F¡FÓ+Ð+ñ r"   c                ó   € R# )z*Convert a rational function to ``dtype``. Nrx   ry   s   &&&r   Úfrom_FractionFieldÚDomain.from_FractionFieldŽ  r~   r"   c                óN   € V P                  VP                  VP                  4      # )z.Convert an ``ExtensionElement`` to ``dtype``. )rL   r   Úringry   s   &&&r   Úfrom_MonogenicFiniteExtensionÚ$Domain.from_MonogenicFiniteExtension’  s   € à�‰˜qŸu™u b§g¡gÓ.Ð.r"   c                ó8   € V P                  VP                  4      # ©z&Convert a ``EX`` object to ``dtype``. )rb   Úexry   s   &&&r   Úfrom_ExpressionDomainÚDomain.from_ExpressionDomain–  s   € à�}‰}˜QŸT™TÓ"Ð"r"   c                ó$   € V P                  V4      # r§   )rb   ry   s   &&&r   Úfrom_ExpressionRawDomainÚDomain.from_ExpressionRawDomainš  s   € à�}‰}˜QÓÐr"   c                ó„   € VP                  4       ^ 8:  d+   V P                  VP                  4       VP                  4      # R# r›   )Údegreer`   ra   rœ   ry   s   &&&r   Úfrom_GlobalPolynomialRingÚ Domain.from_GlobalPolynomialRingž  s/   € à�8‰8‹:˜Œ?Ø—:‘:˜aŸd™d›f b§f¡fÓ-Ð-ñ r"   c                	ó$   € V P                  W4      # r   )r    ry   s   &&&r   Úfrom_GeneralizedPolynomialRingÚ%Domain.from_GeneralizedPolynomialRing£  s   € Ø×$Ñ$ QÓ+Ð+r"   c           
     	óZ  € V P                   '       d,   \        V P                  4      \        V4      ,          '       g>   VP                   '       dM   \        VP                  4      \        V4      ,          '       d"   \        R V : RV: R\	        V4      : R24      hV P                  V4      # )úCannot unify ú with z, given z generators)Úis_CompositeÚsetÚsymbolsr   ÚtupleÚunify)r{   rz   rº   s   &&&r   Úunify_with_symbolsÚDomain.unify_with_symbols¦  sp   € Ø�O�OˆO¤ R§Z¡Z£´3°w³<×!?Ô!?ÀbÇoÇoÀoÔ[^Ð_a×_iÑ_iÓ[jÔmpÐqxÓmy×[yÔ[yÝ#ÓVXÓZ\Ô^cÐdkÖ^lÐ$mÓnÐnà�x‰x˜‹|Ðr"   c                óÊ  € V P                   '       d   V P                  MT pVP                   '       d   VP                  MTpV P                   '       d   V P                  MRpVP                   '       d   VP                  MRpVP                  V4      p\	        WE4      pV P                   '       d   V P
                  MVP
                  pV P                  '       d   VP                  '       g%   VP                  '       dk   V P                  '       dY   VP                  '       d   VP                  '       g5   VP                  '       d#   VP                  '       d   VP                  4       pV P                   '       dD   VP                   '       d%   V P                  '       g   VP                  '       d   V P                  p	MVP                  p	^ RIHp
 Wš8X  d	   V	! Wg4      # V	! WgV4      # )z2Unify two domains where at least one is composite.)ÚGlobalPolynomialRingrx   )r¸   rœ   rº   r¼   r   ÚorderÚis_FractionFieldÚis_PolynomialRingÚis_FieldÚhas_assoc_RingÚget_ringr,   Ú&sympy.polys.domains.old_polynomialringrÀ   )r{   rz   Ú	K0_groundÚ	K1_groundÚ
K0_symbolsÚ
K1_symbolsÚdomainrº   rÁ   ÚclsrÀ   s   &&         r   Úunify_compositeÚDomain.unify_composite¬  sA  € à ŸoŸo˜o�B—F’F°2ˆ	Ø ŸoŸo˜o�B—F’F°2ˆ	à#%§?§? ?�R—Z’Z¸ˆ
Ø#%§?§? ?�R—Z’Z¸ˆ
à—‘ Ó+ˆÜ˜jÓ5ˆØŸOŸO˜O�—’°·±ˆð × × Ð  R×%9×%9Ð%9Ø× × Ð  R×%9×%9Ð%9Ø×$×$Ð$¨I×,>×,>Ð,>ÀFÇOÇOÀOØ×&×&Ð&Ø—_‘_Ó&ˆFà�?�?ˆ? B§O§O O°r×7J×7JÐ7JÈb×Nb×NbÐNbØ—,‘,‰Cà—,‘,ˆCõ
 	PØÔ&Ù�vÓ'Ð'á�6 EÓ*Ð*r"   c                ó’	  € Ve   V P                  W4      # W8X  d   V # V P                  '       d   VP                  '       gH   V P                  4       VP                  4       8w  d   \        RV : RV: 24      hV P	                  V4      # V P
                  '       d   V # VP
                  '       d   V# V P                  '       d   V # VP                  '       d   V# V P                  '       g   VP                  '       dÁ   VP                  '       d   YrVP                  '       dT   \        \        V P                  VP                  .4      4      ^,          V P                  8X  d   YrVP                  V 4      # VP                  V P                  4      pV P                  P                  V4      pV P                  V4      # V P                   '       g   VP                   '       d   V P	                  V4      # VP"                  '       d   YrV P"                  '       d]   VP"                  '       g   VP$                  '       d7   V P&                  VP&                  8¼  d   V # ^ RIHp V! VP&                  R7      # V # VP$                  '       d   YrV P$                  '       dq   VP$                  '       d    V P&                  VP&                  8¼  d   V # V# VP,                  '       g   VP.                  '       d   ^ RIHp V! V P&                  R7      # V # VP0                  '       d   YrV P0                  '       d®   VP,                  '       d   VP3                  4       pVP.                  '       d   VP5                  4       pVP0                  '       dV   V P6                  ! V P8                  P                  VP8                  4      .\;        V P<                  VP<                  4      O5!  # V # V P.                  '       d   V # VP.                  '       d   V# V P,                  '       d%   VP>                  '       d   V P3                  4       p V # VP,                  '       d%   V P>                  '       d   VP3                  4       pV# V P>                  '       d   V # VP>                  '       d   V# V P@                  '       d   V # VP@                  '       d   V# ^ RI!H"p V# )zú
Construct a minimal domain that contains elements of ``K0`` and ``K1``.

Known domains (from smallest to largest):

- ``GF(p)``
- ``ZZ``
- ``QQ``
- ``RR(prec, tol)``
- ``CC(prec, tol)``
- ``ALG(a, b, c)``
- ``K[x, y, z]``
- ``K(x, y, z)``
- ``EX``

r¶   r·   )rR   )Úprec)ÚEX)#r½   Úhas_CharacteristicZeroÚcharacteristicr   rÎ   Úis_EXRAWÚis_EXÚis_FiniteExtensionÚlistr   ÚmodulusÚ
set_domainÚdropÚsymbolrÌ   r¼   r¸   Úis_ComplexFieldÚis_RealFieldÚ	precisionÚ sympy.polys.domains.complexfieldrR   Úis_GaussianRingÚis_GaussianFieldÚis_AlgebraicFieldÚ	get_fieldÚas_AlgebraicFieldr,   rœ   r   Úorig_extÚis_RationalFieldÚis_IntegerRingrY   rÒ   )r{   rz   rº   rR   rÒ   s   &&&  r   r¼   ÚDomain.unifyÍ  s•  € ð" ÒØ×(Ñ(¨Ó5Ð5àŒ8ØˆIà×)×)Ð)¨b×.G×.GÐ.Gà× Ñ Ó" b×&7Ñ&7Ó&9Ô9Ý'ÃRÊÐ(LÓMÐMð
 ×%Ñ% bÓ)Ð)ð
 �;�;ˆ;ØˆIØ�;�;ˆ;ØˆIà�8�8ˆ8ØˆIØ�8�8ˆ8ØˆIà× × Ð  B×$9×$9Ð$9Ø×$×$Ð$Ø�BØ×$×$Ð$ô œ §¡¨R¯Z©ZÐ 8Ó9Ó:¸1Õ=ÀÇÁÔKØ˜Ø—}‘} RÓ(Ð(ð —W‘W˜RŸY™YÓ'�Ø—Y‘Y—_‘_ RÓ(�Ø—}‘} RÓ(Ð(à�?�?ˆ?˜bŸoŸo˜oØ×%Ñ% bÓ)Ð)à××ÐØ�Ø××ÐØ×!×!Ð! R§_§_ _Ø—<‘< 2§<¡<Ô/Ø�IåMÙ'¨R¯\©\Ô:Ð:à�	à�?�?ˆ?Ø�Ø�?�?ˆ?Ø��ˆØ—<‘< 2§<¡<Ô/Ø�Ià�IØ×#×#Ð# r×':×':Ð':ÝIÙ#¨¯©Ô6Ð6à�	à××ÐØ�Ø××ÐØ×!×!Ð!Ø—\‘\“^�Ø×"×"Ð"Ø×)Ñ)Ó+�Ø×#×#Ð#Ø—|’| B§F¡F§L¡L°·±Ó$8Ða¼;ÀrÇ{Á{ÐTV×T_ÑT_Ó;`ÓaÐaà�	à××ÐØˆIØ××ÐØˆIà××ÐØ×"×"Ð"Ø—\‘\“^�ØˆIØ××ÐØ×"×"Ð"Ø—\‘\“^�ØˆIà××ÐØˆIØ××ÐØˆIà××ÐØˆIØ××ÐØˆIå*Øˆ	r"   c                ód   € \        V\        4      ;'       d    V P                  VP                  8H  # )z0Returns ``True`` if two domains are equivalent. )rZ   r   r   ©r   Úothers   &&r   Ú__eq__ÚDomain.__eq__N  s&   € ô ˜%¤Ó(×FÐF¨T¯Z©Z¸5¿;¹;Ñ-FÐFr"   c                ó   € W8X  * # )z1Returns ``False`` if two domains are equivalent. rx   rë   s   &&r   Ú__ne__ÚDomain.__ne__S  s   € àÒ Ð r"   c                óº   € . pV FR  p\        V\        4      '       d#   VP                  V P                  V4      4       K;  VP                  V ! V4      4       KT  	  V# )z5Rersively apply ``self`` to all elements of ``seq``. )rZ   rØ   ÚappendÚmap)r   ÚseqrK   Úelts   &&  r   rô   Ú
Domain.mapW  sI   € àˆãˆCÜ˜#œt×$Ò$Ø—‘˜dŸh™h s›mÖ,à—‘™d 3›iÖ(ñ	 ð ˆr"   c                ó&   € \        RV ,          4      h)z)Returns a ring associated with ``self``. z#there is no ring associated with %s©r   r   s   &r   rÆ   ÚDomain.get_ringc  s   € äÐ?À$ÕFÓGÐGr"   c                ó&   € \        RV ,          4      h)z*Returns a field associated with ``self``. z$there is no field associated with %srù   r   s   &r   rä   ÚDomain.get_fieldg  s   € äÐ@À4ÕGÓHÐHr"   c                ó   € V # )z2Returns an exact domain associated with ``self``. rx   r   s   &r   Ú	get_exactÚDomain.get_exactk  s   € àˆr"   c                óh   € \        VR4      '       d   V P                  ! V!  # V P                  V4      # )z0The mathematical way to make a polynomial ring. Ú__iter__)ÚhasattrÚ	poly_ring©r   rº   s   &&r   Ú__getitem__ÚDomain.__getitem__o  s-   € ä�7˜J×'Ò'Ø—>’> 7Ñ+Ð+à—>‘> 'Ó*Ð*r"   rÁ   c               ó    € ^ RI Hp V! WV4      # ©z(Returns a polynomial ring, i.e. `K[X]`. )ÚPolynomialRing)Ú"sympy.polys.domains.polynomialringr	  )r   rÁ   rº   r	  s   &$* r   r  ÚDomain.poly_ringv  s   € åEÙ˜d¨UÓ3Ð3r"   c               ó    € ^ RI Hp V! WV4      # ©z'Returns a fraction field, i.e. `K(X)`. )ÚFractionField)Ú!sympy.polys.domains.fractionfieldr  )r   rÁ   rº   r  s   &$* r   Ú
frac_fieldÚDomain.frac_field{  s   € åCÙ˜T¨EÓ2Ð2r"   c                ó&   € ^ RI Hp V! V .VO5/ VB # r  )rÇ   r	  )r   rº   Úkwargsr	  s   &*, r   Úold_poly_ringÚDomain.old_poly_ring€  s   € åIÙ˜dÐ7 WÒ7°Ñ7Ð7r"   c                ó&   € ^ RI Hp V! V .VO5/ VB # r  )Ú%sympy.polys.domains.old_fractionfieldr  )r   rº   r  r  s   &*, r   Úold_frac_fieldÚDomain.old_frac_field…  s   € åGÙ˜TÐ6 GÒ6¨vÑ6Ð6r"   c               ó&   € \        RV ,          4      h)z6Returns an algebraic field, i.e. `K(\alpha, \ldots)`. z%Cannot create algebraic field over %srù   )r   r   Ú	extensions   &$*r   Úalgebraic_fieldÚDomain.algebraic_fieldŠ  s   € äÐAÀDÕHÓIÐIr"   c                óZ   € ^ RI Hp V! W4      p\        WRR7      pV P                  WbR7      # )aÿ  
Convenience method to construct an algebraic extension on a root of a
polynomial, chosen by root index.

Parameters
==========

poly : :py:class:`~.Poly`
    The polynomial whose root generates the extension.
alias : str, optional (default=None)
    Symbol name for the generator of the extension.
    E.g. "alpha" or "theta".
root_index : int, optional (default=-1)
    Specifies which root of the polynomial is desired. The ordering is
    as defined by the :py:class:`~.ComplexRootOf` class. The default of
    ``-1`` selects the most natural choice in the common cases of
    quadratic and cyclotomic fields (the square root on the positive
    real or imaginary axis, resp. $\mathrm{e}^{2\pi i/n}$).

Examples
========

>>> from sympy import QQ, Poly
>>> from sympy.abc import x
>>> f = Poly(x**2 - 2)
>>> K = QQ.alg_field_from_poly(f)
>>> K.ext.minpoly == f
True
>>> g = Poly(8*x**3 - 6*x - 1)
>>> L = QQ.alg_field_from_poly(g, "alpha")
>>> L.ext.minpoly == g
True
>>> L.to_sympy(L([1, 1, 1]))
alpha**2 + alpha + 1

)ÚCRootOf)r   )Úsympy.polys.rootoftoolsr  r   r  )r   Úpolyr   Ú
root_indexr  ÚrootÚalphas   &&&&   r   Úalg_field_from_polyÚDomain.alg_field_from_polyŽ  s0   € õJ 	4Ù�tÓ(ˆÜ Ô2ˆØ×#Ñ# EÐ#Ó7Ð7r"   c                óv   € ^ RI Hp V'       d   V\        V4      ,          pV P                  V! W4      VVR7      # )aº  
Convenience method to construct a cyclotomic field.

Parameters
==========

n : int
    Construct the nth cyclotomic field.
ss : boolean, optional (default=False)
    If True, append *n* as a subscript on the alias string.
alias : str, optional (default="zeta")
    Symbol name for the generator.
gen : :py:class:`~.Symbol`, optional (default=None)
    Desired variable for the cyclotomic polynomial that defines the
    field. If ``None``, a dummy variable will be used.
root_index : int, optional (default=-1)
    Specifies which root of the polynomial is desired. The ordering is
    as defined by the :py:class:`~.ComplexRootOf` class. The default of
    ``-1`` selects the root $\mathrm{e}^{2\pi i/n}$.

Examples
========

>>> from sympy import QQ, latex
>>> K = QQ.cyclotomic_field(5)
>>> K.to_sympy(K([-1, 1]))
1 - zeta
>>> L = QQ.cyclotomic_field(7, True)
>>> a = L.to_sympy(L([-1, 1]))
>>> print(a)
1 - zeta7
>>> print(latex(a))
1 - \zeta_{7}

)Úcyclotomic_poly)r   r"  )Úsympy.polys.specialpolysr(  r'   r%  )r   ÚnÚssr   Úgenr"  r(  s   &&&&&& r   Úcyclotomic_fieldÚDomain.cyclotomic_field¸  s<   € õH 	=ßØ”S˜“V�OˆEØ×'Ñ'©¸Ó(?ÀuØ3=ð (ó ?ð 	?r"   c                ó   € \         h)z$Inject generators into this domain. r   r  s   &*r   ÚinjectÚDomain.injectâ  ó   € ä!Ð!r"   c                ó6   € V P                   '       d   V # \        h)z"Drop generators from this domain. )Ú	is_Simpler   r  s   &*r   rÛ   ÚDomain.dropæ  s   € à�>�>ˆ>ØˆKÜ!Ð!r"   c                ó   € V'       * # )zReturns True if ``a`` is zero. rx   ri   s   &&r   Úis_zeroÚDomain.is_zeroì  s	   € àŒuˆr"   c                ó   € WP                   8H  # )zReturns True if ``a`` is one. )r   ri   s   &&r   Úis_oneÚDomain.is_oneð  s   € à—H‘H‰}Ðr"   c                ó   € V^ 8„  # )z#Returns True if ``a`` is positive. rx   ri   s   &&r   Úis_positiveÚDomain.is_positiveô  ó   € à�1‰uˆr"   c                ó   € V^ 8  # )z#Returns True if ``a`` is negative. rx   ri   s   &&r   Úis_negativeÚDomain.is_negativeø  r?  r"   c                ó   € V^ 8*  # )z'Returns True if ``a`` is non-positive. rx   ri   s   &&r   Úis_nonpositiveÚDomain.is_nonpositiveü  ó   € à�A‰vˆr"   c                ó   € V^ 8¬  # )z'Returns True if ``a`` is non-negative. rx   ri   s   &&r   Úis_nonnegativeÚDomain.is_nonnegative   rF  r"   c                	ób   € V P                  V4      '       d   V P                  ) # V P                  # r   )rA  r   ri   s   &&r   Úcanonical_unitÚDomain.canonical_unit  s(   € Ø×Ñ˜A×ÒØ—H‘H�9Ðà—8‘8ˆOr"   c                ó   € \        V4      # )z.Absolute value of ``a``, implies ``__abs__``. )Úabsri   s   &&r   rN  Ú
Domain.abs
  s   € ä�1‹vˆr"   c                ó   € V) # )z,Returns ``a`` negated, implies ``__neg__``. rx   ri   s   &&r   ÚnegÚ
Domain.neg  ó	   € àˆrˆ	r"   c                ó   € V5# )z-Returns ``a`` positive, implies ``__pos__``. rx   ri   s   &&r   ÚposÚ
Domain.pos  rS  r"   c                ó   € W,           # )z.Sum of ``a`` and ``b``, implies ``__add__``.  rx   ©r   rj   Úbs   &&&r   ÚaddÚ
Domain.add  ó	   € à�uˆr"   c                ó   € W,
          # )z5Difference of ``a`` and ``b``, implies ``__sub__``.  rx   rX  s   &&&r   ÚsubÚ
Domain.sub  r\  r"   c                ó   € W,          # )z2Product of ``a`` and ``b``, implies ``__mul__``.  rx   rX  s   &&&r   ÚmulÚ
Domain.mul  r\  r"   c                ó   € W,          # )z2Raise ``a`` to power ``b``, implies ``__pow__``.  rx   rX  s   &&&r   ÚpowÚ
Domain.pow"  s	   € à�vˆr"   c                ó   € \         h)a  Exact quotient of *a* and *b*. Analogue of ``a / b``.

Explanation
===========

This is essentially the same as ``a / b`` except that an error will be
raised if the division is inexact (if there is any remainder) and the
result will always be a domain element. When working in a
:py:class:`~.Domain` that is not a :py:class:`~.Field` (e.g. :ref:`ZZ`
or :ref:`K[x]`) ``exquo`` should be used instead of ``/``.

The key invariant is that if ``q = K.exquo(a, b)`` (and ``exquo`` does
not raise an exception) then ``a == b*q``.

Examples
========

We can use ``K.exquo`` instead of ``/`` for exact division.

>>> from sympy import ZZ
>>> ZZ.exquo(ZZ(4), ZZ(2))
2
>>> ZZ.exquo(ZZ(5), ZZ(2))
Traceback (most recent call last):
    ...
ExactQuotientFailed: 2 does not divide 5 in ZZ

Over a :py:class:`~.Field` such as :ref:`QQ`, division (with nonzero
divisor) is always exact so in that case ``/`` can be used instead of
:py:meth:`~.Domain.exquo`.

>>> from sympy import QQ
>>> QQ.exquo(QQ(5), QQ(2))
5/2
>>> QQ(5) / QQ(2)
5/2

Parameters
==========

a: domain element
    The dividend
b: domain element
    The divisor

Returns
=======

q: domain element
    The exact quotient

Raises
======

ExactQuotientFailed: if exact division is not possible.
ZeroDivisionError: when the divisor is zero.

See also
========

quo: Analogue of ``a // b``
rem: Analogue of ``a % b``
div: Analogue of ``divmod(a, b)``

Notes
=====

Since the default :py:attr:`~.Domain.dtype` for :ref:`ZZ` is ``int``
(or ``mpz``) division as ``a / b`` should not be used as it would give
a ``float`` which is not a domain element.

>>> ZZ(4) / ZZ(2) # doctest: +SKIP
2.0
>>> ZZ(5) / ZZ(2) # doctest: +SKIP
2.5

On the other hand with `SYMPY_GROUND_TYPES=flint` elements of :ref:`ZZ`
are ``flint.fmpz`` and division would raise an exception:

>>> ZZ(4) / ZZ(2) # doctest: +SKIP
Traceback (most recent call last):
...
TypeError: unsupported operand type(s) for /: 'fmpz' and 'fmpz'

Using ``/`` with :ref:`ZZ` will lead to incorrect results so
:py:meth:`~.Domain.exquo` should be used instead.

r   rX  s   &&&r   ÚexquoÚDomain.exquo&  s   € ôr "Ð!r"   c                ó   € \         h)a  Quotient of *a* and *b*. Analogue of ``a // b``.

``K.quo(a, b)`` is equivalent to ``K.div(a, b)[0]``. See
:py:meth:`~.Domain.div` for more explanation.

See also
========

rem: Analogue of ``a % b``
div: Analogue of ``divmod(a, b)``
exquo: Analogue of ``a / b``
r   rX  s   &&&r   ÚquoÚ
Domain.quo�  ó
   € ô "Ð!r"   c                ó   € \         h)a  Modulo division of *a* and *b*. Analogue of ``a % b``.

``K.rem(a, b)`` is equivalent to ``K.div(a, b)[1]``. See
:py:meth:`~.Domain.div` for more explanation.

See also
========

quo: Analogue of ``a // b``
div: Analogue of ``divmod(a, b)``
exquo: Analogue of ``a / b``
r   rX  s   &&&r   ÚremÚ
Domain.rem�  rl  r"   c                ó   € \         h)a{  Quotient and remainder for *a* and *b*. Analogue of ``divmod(a, b)``

Explanation
===========

This is essentially the same as ``divmod(a, b)`` except that is more
consistent when working over some :py:class:`~.Field` domains such as
:ref:`QQ`. When working over an arbitrary :py:class:`~.Domain` the
:py:meth:`~.Domain.div` method should be used instead of ``divmod``.

The key invariant is that if ``q, r = K.div(a, b)`` then
``a == b*q + r``.

The result of ``K.div(a, b)`` is the same as the tuple
``(K.quo(a, b), K.rem(a, b))`` except that if both quotient and
remainder are needed then it is more efficient to use
:py:meth:`~.Domain.div`.

Examples
========

We can use ``K.div`` instead of ``divmod`` for floor division and
remainder.

>>> from sympy import ZZ, QQ
>>> ZZ.div(ZZ(5), ZZ(2))
(2, 1)

If ``K`` is a :py:class:`~.Field` then the division is always exact
with a remainder of :py:attr:`~.Domain.zero`.

>>> QQ.div(QQ(5), QQ(2))
(5/2, 0)

Parameters
==========

a: domain element
    The dividend
b: domain element
    The divisor

Returns
=======

(q, r): tuple of domain elements
    The quotient and remainder

Raises
======

ZeroDivisionError: when the divisor is zero.

See also
========

quo: Analogue of ``a // b``
rem: Analogue of ``a % b``
exquo: Analogue of ``a / b``

Notes
=====

If ``gmpy`` is installed then the ``gmpy.mpq`` type will be used as
the :py:attr:`~.Domain.dtype` for :ref:`QQ`. The ``gmpy.mpq`` type
defines ``divmod`` in a way that is undesirable so
:py:meth:`~.Domain.div` should be used instead of ``divmod``.

>>> a = QQ(1)
>>> b = QQ(3, 2)
>>> a               # doctest: +SKIP
mpq(1,1)
>>> b               # doctest: +SKIP
mpq(3,2)
>>> divmod(a, b)    # doctest: +SKIP
(mpz(0), mpq(1,1))
>>> QQ.div(a, b)    # doctest: +SKIP
(mpq(2,3), mpq(0,1))

Using ``//`` or ``%`` with :ref:`QQ` will lead to incorrect results so
:py:meth:`~.Domain.div` should be used instead.

r   rX  s   &&&r   ÚdivÚ
Domain.divŸ  s   € ôh "Ð!r"   c                ó   € \         h)z5Returns inversion of ``a mod b``, implies something. r   rX  s   &&&r   ÚinvertÚDomain.invertõ  r2  r"   c                ó   € \         h)z!Returns ``a**(-1)`` if possible. r   ri   s   &&r   ÚrevertÚDomain.revertù  r2  r"   c                ó   € \         h)zReturns numerator of ``a``. r   ri   s   &&r   ÚnumerÚDomain.numerý  r2  r"   c                ó   € \         h)zReturns denominator of ``a``. r   ri   s   &&r   ÚdenomÚDomain.denom  r2  r"   c                ó0   € V P                  W4      w  r4pW53# )z&Half extended GCD of ``a`` and ``b``. )Úgcdex)r   rj   rY  ÚsÚtÚhs   &&&   r   Ú
half_gcdexÚDomain.half_gcdex  s   € à—*‘*˜QÓ"‰ˆˆaØˆtˆr"   c                ó   € \         h)z!Extended GCD of ``a`` and ``b``. r   rX  s   &&&r   r€  ÚDomain.gcdex
  r2  r"   c                óp   € V P                  W4      pV P                  W4      pV P                  W#4      pW4V3# )z.Returns GCD and cofactors of ``a`` and ``b``. )Úgcdrj  )r   rj   rY  r‰  ÚcfaÚcfbs   &&&   r   Ú	cofactorsÚDomain.cofactors  s5   € à�h‰h�q‹nˆØ�h‰h�qÓˆØ�h‰h�qÓˆØ˜ˆ}Ðr"   c                ó   € \         h)z Returns GCD of ``a`` and ``b``. r   rX  s   &&&r   r‰  Ú
Domain.gcd  r2  r"   c                ó   € \         h)z Returns LCM of ``a`` and ``b``. r   rX  s   &&&r   ÚlcmÚ
Domain.lcm  r2  r"   c                ó   € \         h)z#Returns b-base logarithm of ``a``. r   rX  s   &&&r   ÚlogÚ
Domain.log  r2  r"   c                ó   € \         h)a  Returns a (possibly inexact) square root of ``a``.

Explanation
===========
There is no universal definition of "inexact square root" for all
domains. It is not recommended to implement this method for domains
other then :ref:`ZZ`.

See also
========
exsqrt
r   ri   s   &&r   ÚsqrtÚDomain.sqrt!  rl  r"   c                ó   € \         h)a>  Returns whether ``a`` is a square in the domain.

Explanation
===========
Returns ``True`` if there is an element ``b`` in the domain such that
``b * b == a``, otherwise returns ``False``. For inexact domains like
:ref:`RR` and :ref:`CC`, a tiny difference in this equality can be
tolerated.

See also
========
exsqrt
r   ri   s   &&r   Ú	is_squareÚDomain.is_square0  s
   € ô "Ð!r"   c                ó   € \         h)aÏ  Principal square root of a within the domain if ``a`` is square.

Explanation
===========
The implementation of this method should return an element ``b`` in the
domain such that ``b * b == a``, or ``None`` if there is no such ``b``.
For inexact domains like :ref:`RR` and :ref:`CC`, a tiny difference in
this equality can be tolerated. The choice of a "principal" square root
should follow a consistent rule whenever possible.

See also
========
sqrt, is_square
r   ri   s   &&r   ÚexsqrtÚDomain.exsqrt@  s
   € ô "Ð!r"   c                óF   € V P                  V4      P                  ! V3/ VB # )z*Returns numerical approximation of ``a``. )rn   Úevalf)r   rj   rÑ   Úoptionss   &&&,r   r   ÚDomain.evalfQ  s!   € à�}‰}˜QÓ×%Ò% dÑ6¨gÑ6Ð6r"   c                	ó   € V# r   rx   ri   s   &&r   ÚrealÚDomain.realW  s   € Øˆr"   c                	ó   € V P                   # r   )r   ri   s   &&r   ÚimagÚDomain.imagZ  s   € Ø�y‰yÐr"   c                ó
   € W8H  # )z+Check if ``a`` and ``b`` are almost equal. rx   )r   rj   rY  Ú	tolerances   &&&&r   ÚalmosteqÚDomain.almosteq]  s	   € à‰vˆr"   c                ó   € \        R4      h)z*Return the characteristic of this domain. zcharacteristic()r   r   s   &r   rÔ   ÚDomain.characteristica  s   € ä!Ð"4Ó5Ð5r"   rx   r   )Néÿÿÿÿ)FÚzetaNr¯  )‰r-   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   Ú__annotations__r   r   Úis_RingrÄ   rÅ   Úhas_assoc_FieldÚis_FiniteFieldÚis_FFrè   Úis_ZZrç   Úis_QQrá   Úis_ZZ_Irâ   Úis_QQ_IrÞ   Úis_RRrÝ   Úis_CCrã   Úis_AlgebraicrÃ   Úis_PolyrÂ   Úis_FracÚis_SymbolicDomainrÖ   Úis_SymbolicRawDomainrÕ   r×   Úis_Exactr_   r4  r¸   Úis_PIDrÓ   r   r   r    r$   r(   r.   r4   Úpropertyr8   r;   r>   rL   r`   rX   rk   rn   rb   rt   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-  r0  rÛ   r7  r:  r=  rA  rD  rH  rK  rN  rQ  rU  rZ  r^  ra  rd  rg  rj  rn  rq  rt  rw  rz  r}  r„  r€  rŒ  r‰  r‘  r”  r—  rš  r�  r   r*  r¤  r§  r«  rÔ   Ú__static_attributes__rx   r"   r   r   r      s  ‡ ñhðT €Eˆ;Óðð, €Dˆ#Óðð €CˆƒOðð €Gðð$ €Hðð" €Nðð  €Oðð  #Ð"€N�UØ"Ð"€N�UØ$Ð$Ð�uØ %Ð%€O�gØ!&Ð&Ð�wØ Ð €L�5Ø#Ð#€O�eØ',Ð,Ð˜Ø"'Ð'Ð˜Ø!&Ð&Ð�wØ %Ð%Ð˜Ø&+Ð+Ð˜8ØÐà€HØ€Là€IØ€Là€Fðð" #Ðà€CˆÓØ€Eˆ:Óò"òòò;ò!ð ñó ðòò!òrô"AdòF,ò	ò["òz"ò8*òòòòòòòòòòò,ò
ò/ò#ò ò.ò
,òò+ôBòBGò
!ò
òHòIòò+ð4¨ô 4ð
3¨ô 3ò
8ò
7ð
J°ô Jô(8ôT(?òT"ò"òòòòòòòòòòòòòòòY"òv"ò"òT"òl"ò"ò"ò"òò
"òò"ò"ò"ò"ò"ò "ô"7ð 	€Aòòôö6r"   r   N)r´  Ú
__future__r   Útypingr   Úsympy.core.numbersr   Ú
sympy.corer   r   Úsympy.core.sortingr   Úsympy.external.gmpyr   Ú!sympy.polys.domains.domainelementr	   Úsympy.polys.orderingsr
   Úsympy.polys.polyerrorsr   r   r   Úsympy.polys.polyutilsr   r   Úsympy.utilitiesr   Úsympy.utilities.iterablesr   r   Ú__all__rx   r"   r   Ú<module>rÖ     sU   ðÙ /å "Ý å .ß %Ý &Ý ,Ý ;Ý %ß QÑ Qß ;Ý "Ý 1ð ÷P6ð P6ó ðP6ðf* ˆ*‚r"   