ó
    Š*£h2= ã                  ó  • S SK Jr  S SKJrJrJrJr  S SKJr  S SK	J
r
  S SKJrJr  S SKrS SKJrJrJr  S SKJr  S S	KJr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 SK!J"r"J#r#J$r$J%r%J&r&  S SK'J(r(J)r)  S SK*J+r+  S SK,J-r-  S SK.J/r/J0r0J1r1  S SK2J3r3J4r4  S SK5J6r6  S SK7J8r8J9r9J:r:J;r;  S SK<J=r=J>r>J?r?  S SK@JArAJBrB  S SKCJDrDJErE  S SKFJGrGJHrHJIrIJJrJJKrKJLrL  S SKMJNrN  S SKOJPrP  S SKQJRrRJSrSJTrTJUrUJVrV  S SKWJXrXJYrY  S SKZJ[r[J\r\  S SK]J^r^  \
" S  S!\4R–                  \4R–                  \4R–                  S"\4R˜                  \4R˜                  \4R˜                  05      r_\ " S# S$\\5      5       r` " S% S&\`5      ra " S' S(\`5      rb " S) S*\`\+5      rc " S+ S,\`\+5      rd " S- S.\`5      re " S/ S0\`\3S19rf " S2 S3\`\3S19rg " S4 S5\`5      rhS6 \?\i'   S7 \?\j'    " S8 S9\`5      rk " S: S;\`5      rlS< rmS= rnS> roS? rpS@ rqSA rrSB rsSC rtSD ruSE rvSF rwSG rx " SH SI\5      ryg)Jé    )Úannotations)ÚAnyÚCallableÚTYPE_CHECKINGÚoverload)Úreduce)Údefaultdict)ÚMappingÚIterableN)ÚKindÚUndefinedKindÚ
NumberKind)ÚBasic)ÚTupleÚ	TupleKind)Úsympify_method_argsÚsympify_return)Ú
EvalfMixin)ÚExpr)ÚLambda)Ú	FuzzyBoolÚ
fuzzy_boolÚfuzzy_orÚ	fuzzy_andÚ	fuzzy_not)ÚFloatÚInteger)Ú	LatticeOp)Úglobal_parameters)ÚEqÚNeÚis_lt)Ú	SingletonÚS)Úordered)ÚsymbolsÚSymbolÚDummyÚuniquely_named_symbol)Ú_sympifyÚsympifyÚ_sympy_converter)ÚexpÚlog)ÚMaxÚMin)ÚAndÚOrÚNotÚXorÚtrueÚfalse)Ú
deprecated)Úsympy_deprecation_warning)ÚiproductÚsiftÚ
roundrobinÚiterableÚsubsets)Ú	func_nameÚ
filldedent)ÚmpiÚmpf)Úprec_to_dpsc                 ó   • g ©N© rE   ó    ÚL/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/sets/sets.pyÚ<lambda>rH   (   s   € ˜$rF   TFc                  óú  • \ rS rSr% SrSrS\S'   SrSrSr	Sr
SrSrSrSrS\S	'   SrS\S
'   SrS\S'   SrSrS\S'   SrS\S'   \\" SSSS9S 5       5       r\(       ar  SLS jr\SMSNS jj5       r\SMSOS jj5       r\SPS j5       r\SMSQS jj5       r\SMSRS jj5       r\SSS j5       r SM     STS jjrSUS jr   SV           SWS jjr\r\S 5       rS r S r!S  r"S! r#S" r$S# r%S$ r&S% r'S& r(\S' 5       r)\S( 5       r*\S) 5       r+\S* 5       r,S+ r-S, r.S- r/S. r0S/ r1S0 r2S1 r3S2 r4S3 r5S4 r6S5 r7S6 r8\S7 5       r9\S8 5       r:\S9 5       r;\S: 5       r<\S; 5       r=\S< 5       r>\S= 5       r?\S> 5       r@\S? 5       rAS@ rBSA rC\D" SB/\E5      SC 5       rF\D" SB/\E5      SD 5       rG\D" SB/\E5      SE 5       rH\D" SB/\E5      SF 5       rI\D" SB/\E5      SG 5       rJ\D" SH\K4/\E5      SI 5       rL\D" SB/\E5      SJ 5       rMSK rNSrOg)XÚSeté/   a§  
The base class for any kind of set.

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

This is not meant to be used directly as a container of items. It does not
behave like the builtin ``set``; see :class:`FiniteSet` for that.

Real intervals are represented by the :class:`Interval` class and unions of
sets by the :class:`Union` class. The empty set is represented by the
:class:`EmptySet` class and available as a singleton as ``S.EmptySet``.
rE   z	tuple[()]Ú	__slots__FNr   Úis_IntersectionÚis_UniversalSetÚis_ComplementÚis_emptyÚis_finite_setú€
        The is_EmptySet attribute of Set objects is deprecated.
        Use 's is S.EmptySet" or 's.is_empty' instead.
        ú1.5údeprecated-is-emptyset©Údeprecated_since_versionÚactive_deprecations_targetc                ó   • g rD   rE   ©Úselfs    rG   Úis_EmptySetÚSet.is_EmptySetQ   ó   € ð rF   c                ó   • g rD   rE   )ÚclsÚargss     rG   Ú__new__ÚSet.__new___   s   € ØrF   c                ó   • g rD   rE   ©rZ   Úarg1Úarg2s      rG   ÚsubsÚSet.subsb   s   € Ø_brF   c                ó   • g rD   rE   ©rZ   re   rf   Úkwargss       rG   rg   rh   d   s   € ØvyrF   c                ó   • g rD   rE   rd   s      rG   rg   rh   f   s   € ØILrF   c                ó   • g rD   rE   rj   s       rG   rg   rh   h   s   € ØrurF   c                ó   • g rD   rE   rj   s       rG   rg   rh   j   s   € Øz}rF   c                ó   • g rD   rE   rj   s       rG   rg   rh   l   s   € Ø^arF   c                ó   • g rD   rE   rj   s       rG   rg   rh   o   s   € àrF   c                ó   •  erD   rE   )rZ   rk   s     rG   ÚsimplifyÚSet.simplifys   s   € Ø�5rF   c                ó   • g rD   rE   )rZ   Únrg   ÚmaxnÚchopÚstrictÚquadÚverboses           rG   ÚevalfÚ	Set.evalfv   s   € ð rF   c                óÈ   •  U R                   nUR                  (       d   eUR                  5       nU$ ! [        [        [
        [        4 a    [        R                  n U$ f = f)z/
Return infimum (if possible) else S.Infinity.
)	ÚinfÚis_comparabler{   ÚNotImplementedErrorÚAttributeErrorÚAssertionErrorÚ
ValueErrorr$   ÚInfinity)ÚexprÚinfimums     rG   Ú_infimum_keyÚSet._infimum_key}   s\   € ð
	!Ø—h‘hˆGØ×(×(Ð(Ð(Ø—m‘m“oˆGð ˆøô $Ü¤´
ð<ó 	!ä—j‘j‰GØˆð	!ús   ‚/3 ³*A!Á A!c                ó   • [        X5      $ )ah  
Returns the union of ``self`` and ``other``.

Examples
========

As a shortcut it is possible to use the ``+`` operator:

>>> from sympy import Interval, FiniteSet
>>> Interval(0, 1).union(Interval(2, 3))
Union(Interval(0, 1), Interval(2, 3))
>>> Interval(0, 1) + Interval(2, 3)
Union(Interval(0, 1), Interval(2, 3))
>>> Interval(1, 2, True, True) + FiniteSet(2, 3)
Union({3}, Interval.Lopen(1, 2))

Similarly it is possible to use the ``-`` operator for set differences:

>>> Interval(0, 2) - Interval(0, 1)
Interval.Lopen(1, 2)
>>> Interval(1, 3) - FiniteSet(2)
Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))

)ÚUnion©rZ   Úothers     rG   ÚunionÚ	Set.union‹   s   € ô2 �TÓ!Ð!rF   c                ó   • [        X5      $ )a`  
Returns the intersection of 'self' and 'other'.

Examples
========

>>> from sympy import Interval

>>> Interval(1, 3).intersect(Interval(1, 2))
Interval(1, 2)

>>> from sympy import imageset, Lambda, symbols, S
>>> n, m = symbols('n m')
>>> a = imageset(Lambda(n, 2*n), S.Integers)
>>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))
EmptySet

©ÚIntersectionr‹   s     rG   Ú	intersectÚSet.intersect¦   s   € ô& ˜DÓ(Ð(rF   c                ó$   • U R                  U5      $ )z
Alias for :meth:`intersect()`
©r’   r‹   s     rG   ÚintersectionÚSet.intersection»   ó   € ð �~‰~˜eÓ$Ð$rF   c                óF   • U R                  U5      [        R                  :H  $ )a  
Returns True if ``self`` and ``other`` are disjoint.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 2).is_disjoint(Interval(1, 2))
False
>>> Interval(0, 2).is_disjoint(Interval(3, 4))
True

References
==========

.. [1] https://en.wikipedia.org/wiki/Disjoint_sets
)r’   r$   ÚEmptySetr‹   s     rG   Úis_disjointÚSet.is_disjointÁ   s   € ð$ �~‰~˜eÓ$¬¯
©
Ñ2Ð2rF   c                ó$   • U R                  U5      $ )z!
Alias for :meth:`is_disjoint()`
)r›   r‹   s     rG   Ú
isdisjointÚSet.isdisjointÕ   ó   € ð ×Ñ Ó&Ð&rF   c                ó   • [        X5      $ )a  
The complement of 'self' w.r.t the given universe.

Examples
========

>>> from sympy import Interval, S
>>> Interval(0, 1).complement(S.Reals)
Union(Interval.open(-oo, 0), Interval.open(1, oo))

>>> Interval(0, 1).complement(S.UniversalSet)
Complement(UniversalSet, Interval(0, 1))

©Ú
Complement©rZ   Úuniverses     rG   Ú
complementÚSet.complementÛ   s   € ô ˜(Ó)Ð)rF   c           	     ód  ^ ^• [        T [        5      (       a½  [        U[        5      (       a¨  [        T R                  5      [        UR                  5      :w  a  U$ / n[	        [        T R                  UR                  5      5      n[        [        U5      5       H/  mU4S j[        U5       5       nUR                  [        U6 5        M1     [        U6 $ [        U[        5      (       aE  [        T [        [        45      (       a)  [        UT R                  [        R                  5      5      $ g [        U[        5      (       a  [        U 4S jUR                    5       6 $ [        U["        5      (       a/  [#        UR                   S   [        UR                   S   T 5      SS9$ U[        R$                  L a  [        R$                  $ [        U[        5      (       aU  ['        UU 4S j5      n[        [        US   6 US    (       a  [#        [        US    6 T SS95      $ [        R$                  5      $ g )Nc              3  óF   >#   • U  H  u  nu  p#UT:w  a  UOX2-
  v •  M     g 7frD   rE   )Ú.0ÚiÚsÚoru   s       €rG   Ú	<genexpr>Ú"Set._complement.<locals>.<genexpr>ø   s&   øé € ÐOÒ>N±°±F°Q˜Q !›V™¨©Ô,Ò>Nùó   ƒ!c              3  ó,   >#   • U  H	  oT-
  v •  M     g 7frD   rE   )rª   r­   rZ   s     €rG   r®   r¯     s   øé € Ð8ªZ¨˜tž8ªZùs   ƒr   é   F©Úevaluatec                ó8   >• [        TR                  U 5      5      $ rD   ©r   Úcontains)ÚxrZ   s    €rG   rH   Ú!Set._complement.<locals>.<lambda>
  s   ø€ ¬:°d·m±mÀAÓ6FÔ+GrF   )Ú
isinstanceÚ
ProductSetÚlenÚsetsÚlistÚzipÚrangeÚ	enumerateÚappendrŠ   ÚIntervalÚ	FiniteSetr‘   r¦   r$   ÚRealsr`   r£   rš   r:   )rZ   rŒ   ÚoverlapsÚpairsr½   Úsiftedru   s   `     @rG   Ú_complementÚSet._complementì   s«  ù€ ä�dœJ×'Ñ'¬J°u¼j×,IÑ,Iä�4—9‘9‹~¤ U§Z¡Z£Ó0Ø�ð ˆHÜœ˜TŸY™Y¨¯
©
Ó3Ó4ˆEÜœ3˜u›:Ö&�ÜO¼iÈÔ>NÓO�Ø—‘¤
¨DÐ 1Ö2ñ 'ô ˜(Ð#Ð#ä˜œx×(Ñ(Ü˜$¤¬9Ð 5×6Ñ6Ü# E¨4¯?©?¼1¿7¹7Ó+CÓDÐDð 7ô ˜œu×%Ñ%ÜÔ8¨U¯ZªZÓ8Ð9Ð9ä˜œz×*Ñ*Ü˜eŸj™j¨™m¬U°5·:±:¸a±=À$Ó-GÐRWÑXÐXà”a—j‘jÒ Ü—:‘:Ðä˜œy×)Ñ)Ü˜%Ô!GÓHˆFäœ V¨E¡]Ð4à˜$—<ô œ9 v¨d¡|Ð5°tÀeÑLó1ð 1ä%&§Z¡Zó1ð 1ð *rF   c                ó   • [        X5      $ )aß  
Returns symmetric difference of ``self`` and ``other``.

Examples
========

>>> from sympy import Interval, S
>>> Interval(1, 3).symmetric_difference(S.Reals)
Union(Interval.open(-oo, 1), Interval.open(3, oo))
>>> Interval(1, 10).symmetric_difference(S.Reals)
Union(Interval.open(-oo, 1), Interval.open(10, oo))

>>> from sympy import S, EmptySet
>>> S.Reals.symmetric_difference(EmptySet)
Reals

References
==========
.. [1] https://en.wikipedia.org/wiki/Symmetric_difference

©ÚSymmetricDifferencer‹   s     rG   Úsymmetric_differenceÚSet.symmetric_difference  s   € ô, # 4Ó/Ð/rF   c                ó>   • [        [        X5      [        X5      5      $ rD   )rŠ   r£   r‹   s     rG   Ú_symmetric_differenceÚSet._symmetric_difference(  s   € Ü”Z Ó,¬j¸Ó.EÓFÐFrF   c                ó   • U R                   $ )zž
The infimum of ``self``.

Examples
========

>>> from sympy import Interval, Union
>>> Interval(0, 1).inf
0
>>> Union(Interval(0, 1), Interval(2, 3)).inf
0

)Ú_infrY   s    rG   r~   ÚSet.inf+  ó   € ð �y‰yÐrF   c                ó   • [        SU -  5      e)Nz	(%s)._inf©r€   rY   s    rG   rÔ   ÚSet._inf<  ó   € ä! +°Ñ"4Ó5Ð5rF   c                ó   • U R                   $ )zŸ
The supremum of ``self``.

Examples
========

>>> from sympy import Interval, Union
>>> Interval(0, 1).sup
1
>>> Union(Interval(0, 1), Interval(2, 3)).sup
3

)Ú_suprY   s    rG   ÚsupÚSet.sup@  rÖ   rF   c                ó   • [        SU -  5      e)Nz	(%s)._suprØ   rY   s    rG   rÜ   ÚSet._supQ  rÚ   rF   c                óœ   • SSK Jn  [        USS9nU R                  U5      n[	        X25      (       a  U$ Uc  U" XSS9$ [
        U   nUc  U$ U$ )a0  
Returns a SymPy value indicating whether ``other`` is contained
in ``self``: ``true`` if it is, ``false`` if it is not, else
an unevaluated ``Contains`` expression (or, as in the case of
ConditionSet and a union of FiniteSet/Intervals, an expression
indicating the conditions for containment).

Examples
========

>>> from sympy import Interval, S
>>> from sympy.abc import x

>>> Interval(0, 1).contains(0.5)
True

As a shortcut it is possible to use the ``in`` operator, but that
will raise an error unless an affirmative true or false is not
obtained.

>>> Interval(0, 1).contains(x)
(0 <= x) & (x <= 1)
>>> x in Interval(0, 1)
Traceback (most recent call last):
...
TypeError: did not evaluate to a bool: None

The result of 'in' is a bool, not a SymPy value

>>> 1 in Interval(0, 2)
True
>>> _ is S.true
False
r²   )ÚContainsT)rx   Fr³   )r·   râ   r+   Ú	_containsrº   Útfn)rZ   rŒ   râ   ÚcÚbs        rG   r·   ÚSet.containsU  s\   € õF 	'Ü˜ dÑ+ˆà�N‰N˜5Ó!ˆÜ�a×"Ñ"ØˆHØ‰9Ù˜E°%Ñ8Ð8Ü�‰FˆØ‰9ØˆHØˆrF   c                óD   • [        [        U 5      R                   S35      e)a�  Test if ``other`` is an element of the set ``self``.

This is an internal method that is expected to be overridden by
subclasses of ``Set`` and will be called by the public
:func:`Set.contains` method or the :class:`Contains` expression.

Parameters
==========

other: Sympified :class:`Basic` instance
    The object whose membership in ``self`` is to be tested.

Returns
=======

Symbolic :class:`Boolean` or ``None``.

A return value of ``None`` indicates that it is unknown whether
``other`` is contained in ``self``. Returning ``None`` from here
ensures that ``self.contains(other)`` or ``Contains(self, other)`` will
return an unevaluated :class:`Contains` expression.

If not ``None`` then the returned value is a :class:`Boolean` that is
logically equivalent to the statement that ``other`` is an element of
``self``. Usually this would be either ``S.true`` or ``S.false`` but
not always.
z
._contains)r€   ÚtypeÚ__name__r‹   s     rG   rã   ÚSet._contains…  s!   € ô8 "¤T¨$£Z×%8Ñ%8Ð$9¸Ð"DÓEÐErF   c                óª  • [        U[        5      (       d  [        SU-  5      eX:X  a  gU R                  nUSL a  g[	        U5      (       a  UR                  (       a  gU R
                  SL a  UR
                  (       a  gU R                  U5      nUb  U$ UR                  U 5      nUb  U$ SSKJ	n  U" X5      nUb  U$ U R                  U5      U :X  a  gg)zß
Returns True if ``self`` is a subset of ``other``.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 0.5).is_subset(Interval(0, 1))
True
>>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))
False

úUnknown argument '%s'TFNr   )Úis_subset_sets)rº   rJ   rƒ   rP   r   rQ   Ú_eval_is_subsetÚ_eval_is_supersetÚsympy.sets.handlers.issubsetrî   r’   )rZ   rŒ   rP   Úretrî   s        rG   Ú	is_subsetÚSet.is_subset£  sØ   € ô ˜%¤×%Ñ%ÜÐ4°uÑ<Ó=Ð=ð ‹=ØØ—=‘=ˆØ�tÒØÜ�x× Ñ  U§^§^ØØ×Ñ Ò&¨5×+>×+>Øð ×"Ñ" 5Ó)ˆØ‰?ØˆJØ×%Ñ% dÓ+ˆØ‰?ØˆJõ 	@Ù˜TÓ)ˆØ‰?ØˆJð �>‰>˜%Ó  DÓ(Øð )rF   c                ó   • g©z;Returns a fuzzy bool for whether self is a subset of other.NrE   r‹   s     rG   rï   ÚSet._eval_is_subsetÔ  ó   € àrF   c                ó   • grö   rE   r‹   s     rG   rð   ÚSet._eval_is_supersetØ  rø   rF   c                ó$   • U R                  U5      $ )z
Alias for :meth:`is_subset()`
©ró   r‹   s     rG   ÚissubsetÚSet.issubsetÝ  r˜   rF   c                ó€   • [        U[        5      (       a  X:g  =(       a    U R                  U5      $ [        SU-  5      e)zä
Returns True if ``self`` is a proper subset of ``other``.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))
True
>>> Interval(0, 1).is_proper_subset(Interval(0, 1))
False

rí   ©rº   rJ   ró   rƒ   r‹   s     rG   Úis_proper_subsetÚSet.is_proper_subsetã  s8   € ô �eœS×!Ñ!Ø‘=×: T§^¡^°EÓ%:Ð:äÐ4°uÑ<Ó=Ð=rF   c                ój   • [        U[        5      (       a  UR                  U 5      $ [        SU-  5      e)zå
Returns True if ``self`` is a superset of ``other``.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 0.5).is_superset(Interval(0, 1))
False
>>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))
True

rí   r   r‹   s     rG   Úis_supersetÚSet.is_supersetö  s1   € ô �eœS×!Ñ!Ø—?‘? 4Ó(Ð(äÐ4°uÑ<Ó=Ð=rF   c                ó$   • U R                  U5      $ )z!
Alias for :meth:`is_superset()`
)r  r‹   s     rG   Ú
issupersetÚSet.issuperset
  r    rF   c                ó€   • [        U[        5      (       a  X:g  =(       a    U R                  U5      $ [        SU-  5      e)zê
Returns True if ``self`` is a proper superset of ``other``.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))
True
>>> Interval(0, 1).is_proper_superset(Interval(0, 1))
False

rí   )rº   rJ   r  rƒ   r‹   s     rG   Úis_proper_supersetÚSet.is_proper_superset  s:   € ô �eœS×!Ñ!Ø‘=×< T×%5Ñ%5°eÓ%<Ð<äÐ4°uÑ<Ó=Ð=rF   c                ó   • SSK Jn  U" U 5      $ )Nr²   ©ÚPowerSet)Úpowersetr  )rZ   r  s     rG   Ú_eval_powersetÚSet._eval_powerset#  s   € Ý&Ù˜‹~ÐrF   c                ó"   • U R                  5       $ )aù  
Find the Power set of ``self``.

Examples
========

>>> from sympy import EmptySet, FiniteSet, Interval

A power set of an empty set:

>>> A = EmptySet
>>> A.powerset()
{EmptySet}

A power set of a finite set:

>>> A = FiniteSet(1, 2)
>>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)
>>> A.powerset() == FiniteSet(a, b, c, EmptySet)
True

A power set of an interval:

>>> Interval(1, 2).powerset()
PowerSet(Interval(1, 2))

References
==========

.. [1] https://en.wikipedia.org/wiki/Power_set

)r  rY   s    rG   r  ÚSet.powerset'  s   € ðB ×"Ñ"Ó$Ð$rF   c                ó   • U R                   $ )z±
The (Lebesgue) measure of ``self``.

Examples
========

>>> from sympy import Interval, Union
>>> Interval(0, 1).measure
1
>>> Union(Interval(0, 1), Interval(2, 3)).measure
2

)Ú_measurerY   s    rG   ÚmeasureÚSet.measureJ  s   € ð �}‰}ÐrF   c                ó"   • U R                  5       $ )aò  
The kind of a Set

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

Any :class:`Set` will have kind :class:`SetKind` which is
parametrised by the kind of the elements of the set. For example
most sets are sets of numbers and will have kind
``SetKind(NumberKind)``. If elements of sets are different in kind than
their kind will ``SetKind(UndefinedKind)``. See
:class:`sympy.core.kind.Kind` for an explanation of the kind system.

Examples
========

>>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet

>>> FiniteSet(Matrix([1, 2])).kind
SetKind(MatrixKind(NumberKind))

>>> Interval(1, 2).kind
SetKind(NumberKind)

>>> EmptySet.kind
SetKind()

A :class:`sympy.sets.powerset.PowerSet` is a set of sets:

>>> PowerSet({1, 2, 3}).kind
SetKind(SetKind(NumberKind))

A :class:`ProductSet` represents the set of tuples of elements of
other sets. Its kind is :class:`sympy.core.containers.TupleKind`
parametrised by the kinds of the elements of those sets:

>>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))
>>> list(p)
[(1, 3), (2, 3), (1, 4), (2, 4)]
>>> p.kind
SetKind(TupleKind(NumberKind, NumberKind))

When all elements of the set do not have same kind, the kind
will be returned as ``SetKind(UndefinedKind)``:

>>> FiniteSet(0, Matrix([1, 2])).kind
SetKind(UndefinedKind)

The kind of the elements of a set are given by the ``element_kind``
attribute of ``SetKind``:

>>> Interval(1, 2).kind.element_kind
NumberKind

See Also
========

NumberKind
sympy.core.kind.UndefinedKind
sympy.core.containers.TupleKind
MatrixKind
sympy.matrices.expressions.sets.MatrixSet
sympy.sets.conditionset.ConditionSet
Rationals
Naturals
Integers
sympy.sets.fancysets.ImageSet
sympy.sets.fancysets.Range
sympy.sets.fancysets.ComplexRegion
sympy.sets.powerset.PowerSet
sympy.sets.sets.ProductSet
sympy.sets.sets.Interval
sympy.sets.sets.Union
sympy.sets.sets.Intersection
sympy.sets.sets.Complement
sympy.sets.sets.EmptySet
sympy.sets.sets.UniversalSet
sympy.sets.sets.FiniteSet
sympy.sets.sets.SymmetricDifference
sympy.sets.sets.DisjointUnion
)Ú_kindrY   s    rG   ÚkindÚSet.kind[  s   € ðf �z‰z‹|ÐrF   c                ó   • U R                   $ )a¿  
The boundary or frontier of a set.

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

A point x is on the boundary of a set S if

1.  x is in the closure of S.
    I.e. Every neighborhood of x contains a point in S.
2.  x is not in the interior of S.
    I.e. There does not exist an open set centered on x contained
    entirely within S.

There are the points on the outer rim of S.  If S is open then these
points need not actually be contained within S.

For example, the boundary of an interval is its start and end points.
This is true regardless of whether or not the interval is open.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 1).boundary
{0, 1}
>>> Interval(0, 1, True, False).boundary
{0, 1}
)Ú	_boundaryrY   s    rG   ÚboundaryÚSet.boundary°  s   € ð> �~‰~ÐrF   c                ó@   • [        X R                  5      R                  $ )a‡  
Property method to check whether a set is open.

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

A set is open if and only if it has an empty intersection with its
boundary. In particular, a subset A of the reals is open if and only
if each one of its points is contained in an open interval that is a
subset of A.

Examples
========
>>> from sympy import S
>>> S.Reals.is_open
True
>>> S.Rationals.is_open
False
)r‘   r  rP   rY   s    rG   Úis_openÚSet.is_openÑ  s   € ô* ˜D§-¡-Ó0×9Ñ9Ð9rF   c                ó8   • U R                   R                  U 5      $ )a8  
A property method to check whether a set is closed.

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

A set is closed if its complement is an open set. The closedness of a
subset of the reals is determined with respect to R and its standard
topology.

Examples
========
>>> from sympy import Interval
>>> Interval(0, 1).is_closed
True
)r  ró   rY   s    rG   Ú	is_closedÚSet.is_closedè  s   € ð$ �}‰}×&Ñ& tÓ,Ð,rF   c                ó   • X R                   -   $ )zö
Property method which returns the closure of a set.
The closure is defined as the union of the set itself and its
boundary.

Examples
========
>>> from sympy import S, Interval
>>> S.Reals.closure
Reals
>>> Interval(0, 1).closure
Interval(0, 1)
©r  rY   s    rG   ÚclosureÚSet.closureü  ó   € ð —m‘mÑ#Ð#rF   c                ó   • X R                   -
  $ )a   
Property method which returns the interior of a set.
The interior of a set S consists all points of S that do not
belong to the boundary of S.

Examples
========
>>> from sympy import Interval
>>> Interval(0, 1).interior
Interval.open(0, 1)
>>> Interval(0, 1).boundary.interior
EmptySet
r'  rY   s    rG   ÚinteriorÚSet.interior  r*  rF   c                ó   • [        5       erD   rØ   rY   s    rG   r  ÚSet._boundary  ó   € ä!Ó#Ð#rF   c                ó   • [        SU -  5      e)Nz(%s)._measurerØ   rY   s    rG   r  ÚSet._measure"  s   € ä! /°DÑ"8Ó9Ð9rF   c                ó    • [        [        5      $ rD   ©ÚSetKindr   rY   s    rG   r  Ú	Set._kind&  ó   € Ü”}Ó%Ð%rF   c           	     óŽ   • [        U5      nU R                  " U R                   Vs/ s H  o3R                  US9PM     sn6 $ s  snf ©N©ru   )rB   Úfuncr`   r{   )rZ   ÚprecÚdpsÚargs       rG   Ú_eval_evalfÚSet._eval_evalf)  s:   € Ü˜$ÓˆØ�yŠy°t·y²yÓA²y°Ÿ9™9 s˜9Ó+±yÑAÐBÐBùÒAs   ¦A)rŒ   rJ   c                ó$   • U R                  U5      $ rD   ©r�   r‹   s     rG   Ú__add__ÚSet.__add__-  ó   € à�z‰z˜%Ó Ð rF   c                ó$   • U R                  U5      $ rD   rB  r‹   s     rG   Ú__or__Ú
Set.__or__1  rE  rF   c                ó$   • U R                  U5      $ rD   r•   r‹   s     rG   Ú__and__ÚSet.__and__5  s   € à�~‰~˜eÓ$Ð$rF   c                ó   • [        X5      $ rD   )r»   r‹   s     rG   Ú__mul__ÚSet.__mul__9  ó   € ä˜$Ó&Ð&rF   c                ó   • [        X5      $ rD   rÌ   r‹   s     rG   Ú__xor__ÚSet.__xor__=  s   € ä" 4Ó/Ð/rF   r-   c                ód   • UR                   (       a  US:¼  d  [        SU-  5      e[        U /U-  6 $ )Nr   z'%s: Exponent must be a positive Integer)Ú
is_Integerrƒ   r»   )rZ   r-   s     rG   Ú__pow__ÚSet.__pow__A  s1   € à—— 3¨!£8ÜÐFÈÑLÓMÐMÜ˜D˜6 #™:Ð&Ð&rF   c                ó   • [        X5      $ rD   r¢   r‹   s     rG   Ú__sub__ÚSet.__sub__G  rO  rF   c                ór   • [        U5      nU R                  U5      n[        U   nUc  [        SU-  5      eU$ )Nzdid not evaluate to a bool: %r)r*   rã   rä   Ú	TypeError)rZ   rŒ   rå   ræ   s       rG   Ú__contains__ÚSet.__contains__K  s?   € Ü˜“ˆØ�N‰N˜5Ó!ˆÜ�‰FˆØ‰9ô Ð<¸qÑ@ÓAÐAØˆrF   )r`   úBasic | complexÚreturnrJ   rD   )re   z'Mapping[Basic | complex, Set | complex]rf   ÚNoner_  rJ   )re   z/Iterable[tuple[Basic | complex, Set | complex]]rf   r`  rk   r   r_  rJ   )re   úSet | complexrf   ra  r_  rJ   )re   z)Mapping[Basic | complex, Basic | complex]rf   r`  rk   r   r_  r   )re   z1Iterable[tuple[Basic | complex, Basic | complex]]rf   r`  rk   r   r_  r   )re   r^  rf   r^  rk   r   r_  r   )re   z;Mapping[Basic | complex, Basic | complex] | Basic | complexrf   zBasic | complex | Nonerk   r   r_  r   )r_  rJ   )é   Néd   FFNF)ru   Úintrg   z!dict[Basic, Basic | float] | Nonerv   rd  rw   Úboolrx   re  ry   z
str | Nonerz   re  r_  rJ   )Prê   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rL   Ú__annotations__Ú	is_numberÚis_iterableÚis_intervalÚis_FiniteSetÚis_IntervalÚis_ProductSetÚis_UnionrM   rN   rO   Úis_ComplexRegionrP   rQ   Úpropertyr7   r[   r   ra   r   rg   rr   r{   ru   Ústaticmethodr‡   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  r?  r   ÚNotImplementedrC  rG  rJ  rM  rQ  r   rU  rX  r\  Ú__static_attributes__rE   rF   rG   rJ   rJ   /   sÞ  ‡ ñð €IˆyÓà€IØ€KØ€Kà€LØ€KØ€MØ€HØ!%€O�YÓ%Ø!%€O�YÓ%Ø#€M�9Ó#ØÐà€HˆiÓØ#€M�9Ó#àÙð	ð "'Ø#;ññóó ðö ô	ð 
Ýbó 
ØbØ	Ýyó 
ØyØ	ÛLó 
ØLØ	Ýuó 
ØuØ	Ý}ó 
Ø}Ø	Ûaó 
Øað 15ð	Ø-ð	Ø@Cð	ØHMõ	ô	ð PTØGLØ;@ð	Øð	Ø)-ð	Ø?Cð	à"ð	à48ð	àEHõ	ð
 ˆàñó ðò"ò6)ò*%ò3ò('ò*ò""1òH0ò0Gð ñó ðð  ñ6ó ð6ð ñó ðð  ñ6ó ð6ò.ò`Fò</òbòò
%ò>ò&>ò('ò>ò&ò!%ðF ñó ðð  ñRó ðRðh ñó ðð@ ñ:ó ð:ð, ñ-ó ð-ð& ñ$ó ð$ð  ñ$ó ð$ð  ñ$ó ð$ð ñ:ó ð:ò&òCñ Ð%Ð&¨Ó7ñ!ó 8ð!ñ Ð%Ð&¨Ó7ñ!ó 8ð!ñ Ð%Ð&¨Ó7ñ%ó 8ð%ñ Ð%Ð&¨Ó7ñ'ó 8ð'ñ Ð%Ð&¨Ó7ñ0ó 8ð0ñ �e˜T�]�O ^Ó4ñ'ó 5ð'ñ
 Ð%Ð&¨Ó7ñ'ó 8ð'õrF   rJ   c                  ó¬   • \ rS rSrSrSrS r\S 5       rS r	S r
S r\S	 5       r\S
 5       rS r\S 5       r\S 5       r\S 5       rS rS rS rSrg)r»   iV  an  
Represents a Cartesian Product of Sets.

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

Returns a Cartesian product given several sets as either an iterable
or individual arguments.

Can use ``*`` operator on any sets for convenient shorthand.

Examples
========

>>> from sympy import Interval, FiniteSet, ProductSet
>>> I = Interval(0, 5); S = FiniteSet(1, 2, 3)
>>> ProductSet(I, S)
ProductSet(Interval(0, 5), {1, 2, 3})

>>> (2, 2) in ProductSet(I, S)
True

>>> Interval(0, 1) * Interval(0, 1) # The unit square
ProductSet(Interval(0, 1), Interval(0, 1))

>>> coin = FiniteSet('H', 'T')
>>> set(coin**2)
{(H, H), (H, T), (T, H), (T, T)}

The Cartesian product is not commutative or associative e.g.:

>>> I*S == S*I
False
>>> (I*I)*I == I*(I*I)
False

Notes
=====

- Passes most operations down to the argument sets

References
==========

.. [1] https://en.wikipedia.org/wiki/Cartesian_product
Tc                óè  • [        U5      S:X  aJ  [        US   5      (       a7  [        US   [        [        45      (       d  [        SSSS9  [        US   5      nU Vs/ s H  n[        U5      PM     nn[        S U 5       5      (       d  [        S5      e[        U5      S:X  a  [        S	5      $ [        R                  U;   a  [        R                  $ [        R                  " U /UQ70 UD6$ s  snf )
Nr²   r   zX
ProductSet(iterable) is deprecated. Use ProductSet(*iterable) instead.
                rS   zdeprecated-productset-iterablerU   c              3  óB   #   • U  H  n[        U[        5      v •  M     g 7frD   ©rº   rJ   ©rª   r¬   s     rG   r®   Ú%ProductSet.__new__.<locals>.<genexpr>”  s   é € Ð4ªt¨!”:˜a¤×%Ð%ªtùó   ‚z-Arguments to ProductSet should be of type SetrE   )r¼   r<   rº   rJ   Úsetr8   Útupler+   Úallr[  rÄ   r$   rš   r   ra   )r_   r½   Úassumptionsr¬   s       rG   ra   ÚProductSet.__new__‡  sÔ   € Üˆt‹9˜‹>œh t¨A¡w×/Ñ/¼
À4ÈÁ7ÌSÔRUÈJ×8WÑ8WÜ%ðð */Ø+Kòô ˜˜a™“>ˆDá$(Ó)¢D˜q”˜–
¡DˆÐ)äÑ4©tÓ4×4Ñ4ÜÐKÓLÐLô ˆt‹9˜‹>Ü˜R“=Ð ä�:‰:˜ÓÜ—:‘:Ðä�}Š}˜SÐ7 4Ò7¨;Ñ7Ð7ùò *s   ÁC/c                ó   • U R                   $ rD   ©r`   rY   s    rG   r½   ÚProductSet.sets   ó   € à�y‰yÐrF   c                ó@   ^• U4S jm[        T" U R                  5      6 $ )Nc              3  ó†   >#   • U  H4  nUR                   (       a  T" UR                  5       S h  v•N   M0  Uv •  M6     g  N7frD   )rp  r½   )r½   r¬   Ú_flattens     €rG   r‰  Ú$ProductSet.flatten.<locals>._flatten¥  s1   øé € Û�Ø—?—?Ù'¨¯©Ó/×/Ò/à”Gò	 á/ùs   ƒ,A¯?°A)r»   r½   )rZ   r‰  s    @rG   ÚflattenÚProductSet.flatten¤  s   ø€ õ	ô ™8 D§I¡IÓ.Ð/Ð/rF   c           	     ó@  • UR                   (       a  g[        U[        5      (       a"  [        U5      [        U R                  5      :w  a  [
        R                  $ [        [        U R                  U5       VVs/ s H  u  p#UR                  U5      PM     snn6 $ s  snnf )zè
``in`` operator for ProductSets.

Examples
========

>>> from sympy import Interval
>>> (2, 3) in Interval(0, 5) * Interval(0, 5)
True

>>> (10, 10) in Interval(0, 5) * Interval(0, 5)
False

Passes operation on to constituent sets
N)
Ú	is_Symbolrº   r   r¼   r½   r$   r6   r1   r¿   r·   )rZ   Úelementr¬   Úes       rG   rã   ÚProductSet._contains¯  sm   € ð  ××Øä˜'¤5×)Ñ)¬S°«\¼SÀÇÁ»^Ó-KÜ—7‘7ˆNä¬s°4·9±9¸gÔ/FÔGÒ/F¡t q�Q—Z‘Z –]Ñ/FÒGÐHÐHùÓGs   Á8B
c           	     óV  • U Vs/ s H  n[        U5      PM     nn[        U5      [        U R                  5      :w  d  [        S U 5       5      (       d  [	        S5      e[        [        U R                  U5       VVs/ s H  u  p#UR                  U5      PM     snn6 $ s  snf s  snnf )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   )rŽ  ©rª   r«   s     rG   r®   Ú+ProductSet.as_relational.<locals>.<genexpr>É  s   é € ð 5.Ú%, —–¢Wùó   ‚z/number of symbols must match the number of sets)r*   r¼   r½   r€  rƒ   r1   r¿   Úas_relational)rZ   r&   r¬   r«   s       rG   r—  ÚProductSet.as_relationalÇ  s–   € Ù(/Ó0ª 1”8˜A–;©ˆÐ0Üˆw‹<œ3˜tŸy™y›>Ó)´ñ 5.Ù%,ó5.÷ 2.ñ 2.äØAóCð Cä´C¸¿	¹	À7Ô4KÔLÒ4K©D¨A�Q—_‘_ QÖ'Ñ4KÒLÐMÐMùò 1ùó
 Ms   …B Á>B%
c                óN   ^ • [        U 4S j[        T R                  5       5       6 $ )Nc              3  óv   >^#   • U  H-  u  mn[        U4S  j[        TR                  5       5       6 v •  M/     g7f)c              3  óh   >#   • U  H'  u  pTU:w  a  X"R                   -   OUR                   v •  M)     g 7frD   r'  )rª   Újræ   r«   s      €rG   r®   Ú1ProductSet._boundary.<locals>.<genexpr>.<genexpr>Ñ  s0   øé € ð $BÚ,@¡D Að 78¸1³f A¯
©
¢NÀ!Ç*Á*Ô$LÚ,@ùs   ƒ/2N)r»   rÁ   r½   )rª   Úar«   rZ   s     @€rG   r®   Ú'ProductSet._boundary.<locals>.<genexpr>Ñ  s;   ùé € ð Bâ,@¡D A qô "ô $BÜ,5°d·i±iÔ,@ó$Bõ Câ,@ùs   „59)rŠ   rÁ   r½   rY   s   `rG   r  ÚProductSet._boundaryÏ  s*   ø€ äô Bä,5°d·i±iÔ,@óBð Cð 	CrF   c                ó:   • [        S U R                   5       5      $ )a!  
A property method which tests whether a set is iterable or not.
Returns True if set is iterable, otherwise returns False.

Examples
========

>>> from sympy import FiniteSet, Interval
>>> I = Interval(0, 1)
>>> A = FiniteSet(1, 2, 3, 4, 5)
>>> I.is_iterable
False
>>> A.is_iterable
True

c              3  ó8   #   • U  H  oR                   v •  M     g 7frD   ©rl  ©rª   r~  s     rG   r®   Ú)ProductSet.is_iterable.<locals>.<genexpr>ç  ó   é € Ð8ªi s—?–?ªiùr–  ©r€  r½   rY   s    rG   rl  ÚProductSet.is_iterableÕ  s   € ô$ Ñ8¨d¯iªiÓ8Ó8Ð8rF   c                ó&   • [        U R                  6 $ )z¾
A method which implements is_iterable property method.
If self.is_iterable returns True (both constituent sets are iterable),
then return the Cartesian Product. Otherwise, raise TypeError.
)r9   r½   rY   s    rG   Ú__iter__ÚProductSet.__iter__é  s   € ô ˜Ÿ™Ð#Ð#rF   c                ó:   • [        S U R                   5       5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   ©rP   r{  s     rG   r®   Ú&ProductSet.is_empty.<locals>.<genexpr>ó  s   é € Ð6ªI qŸ
ž
ªIùr–  )r   r½   rY   s    rG   rP   ÚProductSet.is_emptyñ  s   € äÑ6¨D¯IªIÓ6Ó6Ð6rF   c                óh   • [        S U R                   5       5      n[        U R                  U/5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   ©rQ   r{  s     rG   r®   Ú+ProductSet.is_finite_set.<locals>.<genexpr>÷  ó   é € ÐBº	°1Ÿžº	ùr–  ©r   r½   r   rP   ©rZ   Ú
all_finites     rG   rQ   ÚProductSet.is_finite_setõ  ó*   € äÑB¸¿	º	ÓBÓBˆ
Ü˜Ÿ™¨
Ð3Ó4Ð4rF   c                óL   • SnU R                    H  nXR                  -  nM     U$ ©Nr²   )r½   r  )rZ   r  r¬   s      rG   r  ÚProductSet._measureú  s&   € àˆØ—”ˆAØ—y‘yÑ ŠGñ àˆrF   c                óF   • [        [        S U R                   5       6 5      $ )Nc              3  óL   #   • U  H  oR                   R                  v •  M     g 7frD   )r  Úelement_kindr”  s     rG   r®   Ú#ProductSet._kind.<locals>.<genexpr>  s   é € Ð"JÂ	¸1§6¡6×#6Ö#6Â	ùó   ‚"$)r5  r   r`   rY   s    rG   r  ÚProductSet._kind  s   € Ü”yÑ"JÀÇ	Â	Ó"JÐKÓLÐLrF   c                ó>   • [        S S U R                   5       5      $ )Nc                ó
   • X-  $ rD   rE   ©rž  ræ   s     rG   rH   Ú$ProductSet.__len__.<locals>.<lambda>  s   €  1¢3rF   c              3  ó8   #   • U  H  n[        U5      v •  M     g 7frD   )r¼   r{  s     rG   r®   Ú%ProductSet.__len__.<locals>.<genexpr>  s   é € Ð(Cº°A¬¨Q¯¨ºùr–  )r   r`   rY   s    rG   Ú__len__ÚProductSet.__len__  s   € ÜÑ&Ñ(C¸¿ºÓ(CÓDÐDrF   c                ó,   • [        U R                  5      $ rD   r§  rY   s    rG   Ú__bool__ÚProductSet.__bool__  ó   € Ü�4—9‘9‹~ÐrF   rE   N)rê   rf  rg  rh  ri  rp  ra   rs  r½   r‹  rã   r—  r  rl  rª  rP   rQ   r  r  rÊ  rÍ  rv  rE   rF   rG   r»   r»   V  sµ   † ñ-ð\ €Mò8ð2 ñó ðò0òIò0Nð ñCó ðCð
 ñ9ó ð9ò&$ð ñ7ó ð7ð ñ5ó ð5ð ñó ðòMòEõrF   r»   c                  ój  • \ rS rSrSrSrS S jr\S 5       r\S 5       r	\S 5       r
\S 5       r\S	 5       r\S
 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       rS r\S 5       rS rS r\S 5       rS rS!S jrS rS r\S 5       r\S 5       r S r!Sr"g)"rÃ   i  aŸ  
Represents a real interval as a Set.

Usage:
    Returns an interval with end points ``start`` and ``end``.

    For ``left_open=True`` (default ``left_open`` is ``False``) the interval
    will be open on the left. Similarly, for ``right_open=True`` the interval
    will be open on the right.

Examples
========

>>> from sympy import Symbol, Interval
>>> Interval(0, 1)
Interval(0, 1)
>>> Interval.Ropen(0, 1)
Interval.Ropen(0, 1)
>>> Interval.Ropen(0, 1)
Interval.Ropen(0, 1)
>>> Interval.Lopen(0, 1)
Interval.Lopen(0, 1)
>>> Interval.open(0, 1)
Interval.open(0, 1)

>>> a = Symbol('a', real=True)
>>> Interval(0, a)
Interval(0, a)

Notes
=====
- Only real end points are supported
- ``Interval(a, b)`` with $a > b$ will return the empty set
- Use the ``evalf()`` method to turn an Interval into an mpmath
  ``mpi`` interval instance

References
==========

.. [1] https://en.wikipedia.org/wiki/Interval_%28mathematics%29
Tc           	     ó†  • [        U5      n[        U5      n[        U5      n[        U5      n[        S X44 5       5      (       d  [        SU< SU< 35      e[        [	        S XX!-
  4 5       5      5      (       a  [        S5      e[        X!5      (       a  [        R                  $ X!-
  R                  (       a  [        R                  $ X!:X  a  U(       d  U(       a  [        R                  $ X!:X  aO  U(       dH  U(       dA  U[        R                  L d  U[        R                  L a  [        R                  $ [        U5      $ U[        R                  L a  [        nU[        R                  L a  [        nU[        R                  :X  d  U[        R                  :X  a  [        R                  $ [        R                  " XX#U5      $ )Nc              3  ór   #   • U  H-  n[        U[        [        5      [        [        5      45      v •  M/     g 7frD   )rº   ré   r5   r6   )rª   rž  s     rG   r®   Ú#Interval.__new__.<locals>.<genexpr>>  s.   é € ð .Ú,�ô ˜a¤$¤t£*¬d´5«kÐ!:×;Ð;Ú,ùs   ‚57z>left_open and right_open can have only true/false values, got z and c              3  ó8   #   • U  H  oR                   v •  M     g 7frD   )Úis_extended_realr”  s     rG   r®   rÓ  E  s   é € ÐSÒ;R°a×1Ö1Ò;Rùr–  z$Non-real intervals are not supported)r*   r€  r€   r   r   rƒ   r"   r$   rš   Úis_negativer„   ÚNegativeInfinityrÄ   r5   r   ra   )r_   ÚstartÚendÚ	left_openÚ
right_opens        rG   ra   ÚInterval.__new__7  sX  € ä˜“ˆÜ�s‹mˆÜ˜YÓ'ˆ	Ü˜jÓ)ˆ
äñ .ØÑ,ó.÷ .ñ .å%ã#,ªjð:ó;ð ;ô
 ”YÑS¸EÈÉ	Ñ;RÓSÓS×TÑTÜÐCÓDÐDô �×ÑÜ—:‘:ÐØ‰k×&×&Ü—:‘:Ðà‹<žY®*Ü—:‘:ÐØ‹<¦®jØœŸ
™
Ò" e¬q×/AÑ/AÒ&AÜ—z‘zÐ!Ü˜S“>Ð!ð ”A×&Ñ&Ò&ÜˆIØ”!—*‘*ÒÜˆJØ”A—J‘JÓ #¬×);Ñ);Ó";Ü—:‘:Ðä�}Š}˜S¨¸ÓDÐDrF   c                ó    • U R                   S   $ )z±
The left end point of the interval.

This property takes the same value as the ``inf`` property.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 1).start
0

r   ©Ú_argsrY   s    rG   rØ  ÚInterval.start_  ó   € ð �z‰z˜!‰}ÐrF   c                ó    • U R                   S   $ )z°
The right end point of the interval.

This property takes the same value as the ``sup`` property.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 1).end
1

r²   rÞ  rY   s    rG   rÙ  ÚInterval.endp  rá  rF   c                ó    • U R                   S   $ )zº
True if interval is left-open.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 1, left_open=True).left_open
True
>>> Interval(0, 1, left_open=False).left_open
False

é   rÞ  rY   s    rG   rÚ  ÚInterval.left_open�  rá  rF   c                ó    • U R                   S   $ )z¿
True if interval is right-open.

Examples
========

>>> from sympy import Interval
>>> Interval(0, 1, right_open=True).right_open
True
>>> Interval(0, 1, right_open=False).right_open
False

é   rÞ  rY   s    rG   rÛ  ÚInterval.right_open’  rá  rF   c                ó   • U " XSS5      $ )z.Return an interval including neither boundary.TrE   ©r_   rž  ræ   s      rG   ÚopenÚInterval.open£  s   € ñ �1˜˜tÓ$Ð$rF   c                ó   • U " XSS5      $ )z3Return an interval not including the left boundary.TFrE   rë  s      rG   ÚLopenÚInterval.Lopen¨  s   € ñ �1˜˜uÓ%Ð%rF   c                ó   • U " XSS5      $ )z4Return an interval not including the right boundary.FTrE   rë  s      rG   ÚRopenÚInterval.Ropen­  s   € ñ �1˜ Ó%Ð%rF   c                ó   • U R                   $ rD   ©rØ  rY   s    rG   rÔ   ÚInterval._inf²  ó   € à�z‰zÐrF   c                ó   • U R                   $ rD   ©rÙ  rY   s    rG   rÜ   ÚInterval._sup¶  ó   € à�x‰xˆrF   c                ó   • U R                   $ rD   rõ  rY   s    rG   ÚleftÚInterval.leftº  r÷  rF   c                ó   • U R                   $ rD   rù  rY   s    rG   ÚrightÚInterval.right¾  rû  rF   c                óÂ   • U R                   (       d  U R                  (       a  U R                  U R                  :¬  nOU R                  U R                  :„  n[	        U5      $ rD   )rÚ  rÛ  rØ  rÙ  r   )rZ   Úconds     rG   rP   ÚInterval.is_emptyÂ  s>   € à�>�>˜TŸ_Ÿ_Ø—:‘: §¡Ñ)‰Dà—:‘: §¡Ñ(ˆDÜ˜$ÓÐrF   c                ó.   • U R                   R                  $ rD   )r  Úis_zerorY   s    rG   rQ   ÚInterval.is_finite_setÊ  s   € à�|‰|×#Ñ#Ð#rF   c                óÜ  • U[         R                  :X  au  [        [         R                  U R                  SU R
                  (       + 5      n[        U R                  [         R                  U R                  (       + S5      n[        X#5      $ [        U[        5      (       a5  UR                   Vs/ s H  oDR                  (       d  M  UPM     nnU/ :X  a  g [        R                  X5      $ s  snf ©NT)r$   rÅ   rÃ   r×  rØ  rÚ  rÙ  r„   rÛ  rŠ   rº   rÄ   r`   rk  rJ   rÉ   )rZ   rŒ   rž  ræ   ÚmÚnumss         rG   rÉ   ÚInterval._complementÎ  s¢   € Ø”A—G‘GÓÜœ×+Ñ+¨T¯Z©ZØ 4§>¡>Ô1ó3ˆAä˜Ÿ™¤1§:¡:°4·?±?Ô/BÀDÓIˆAÜ˜“;Ðä�eœY×'Ñ'Ø$ŸzšzÓ9šz˜!¯[­[—A™zˆDÐ9Ø�r‹zØä�‰˜tÓ+Ð+ùò	 :s   Â-C)ÃC)c                óª   • U R                   U R                  4 Vs/ s H$  n[        U5      [        R                  :w  d  M"  UPM&     nn[        U6 $ s  snf rD   )rØ  rÙ  Úabsr$   r„   rÄ   )rZ   ÚpÚfinite_pointss      rG   r  ÚInterval._boundaryÜ  sL   € à%)§Z¡Z°·±Ñ$:ó 2Ò$:˜qÜ ›F¤a§j¡jÑ0÷ Ñ$:ˆð 2ä˜-Ð(Ð(ùò2s   ›!AÁ Ac                óÌ  • [        U[        5      (       aF  U[        R                  L d3  UR                  SL d$  UR                  [        R                  5      (       a  [        $ U R                  [        R                  L a=  U R                  [        R                  L a   UR                  b  [        UR                     $ [        5       nU R                  U5      R                  X!5      $ )NF)rº   r   r$   ÚNaNÚis_realÚhasÚComplexInfinityr6   rØ  r×  rÙ  r„   rä   r(   r—  rg   )rZ   rŒ   Úds      rG   rã   ÚInterval._containsâ  s�   € Ü˜5¤$×'Ñ'¨5´A·E±Eª>Ø�}‰} Ò%¨¯©´1×3DÑ3D×)EÑ)Eô �à�:‰:œ×+Ñ+Ò+°·±¼A¿J¹JÒ0FØ�}‰}Ñ(Ü˜5Ÿ=™=Ñ)Ð)ä‹GˆØ×!Ñ! !Ó$×)Ñ)¨!Ó3Ð3rF   c                óê   • [        U5      nU R                  (       a  XR                  :  nOXR                  :*  nU R                  (       a  U R                  U:  nOU R                  U:*  n[        X25      $ )zARewrite an interval in terms of inequalities and logic operators.)r+   rÛ  rÙ  rÚ  rØ  r1   )rZ   r¸   r   rý  s       rG   r—  ÚInterval.as_relationalð  sT   € ä�A‹JˆØ�?�?ØŸ™‘L‰EàŸ™‘MˆEØ�>�>Ø—:‘: ‘>‰Dà—:‘: ‘?ˆDÜ�4ÓÐrF   c                ó4   • U R                   U R                  -
  $ rD   )rÙ  rØ  rY   s    rG   r  ÚInterval._measureý  s   € à�x‰x˜$Ÿ*™*Ñ$Ð$rF   c                ó    • [        [        5      $ rD   )r5  r   rY   s    rG   r  ÚInterval._kind  s   € Ü”zÓ"Ð"rF   c                ó¢   • [        [        U R                  R                  U5      5      [        U R                  R                  U5      5      5      $ rD   )r@   rA   rØ  r?  rÙ  ©rZ   r<  s     rG   Úto_mpiÚInterval.to_mpi  s<   € Ü”3�t—z‘z×-Ñ-¨dÓ3Ó4Ü�—‘×$Ñ$ TÓ*Ó+ó-ð 	-rF   c                ó¦   • [        U R                  R                  U5      U R                  R                  U5      U R                  U R
                  S9$ )N)rÚ  rÛ  )rÃ   rý  Ú_evalfr   rÚ  rÛ  r   s     rG   r?  ÚInterval._eval_evalf  s@   € Ü˜Ÿ	™	×(Ñ(¨Ó.°·
±
×0AÑ0AÀ$Ó0GØ—n‘n°·±ñBð 	BrF   c                óÂ   • U R                   R                  nX R                  R                  -  nX!R                   R                  -  nX!R                  R                  -  nU$ rD   )rØ  r   rÙ  )rZ   rŒ   r   s      rG   Ú_is_comparableÚInterval._is_comparable  sM   € ØŸ
™
×0Ñ0ˆØŸ™×/Ñ/Ñ/ˆØŸ™×2Ñ2Ñ2ˆØŸ™×0Ñ0Ñ0ˆàÐrF   c                óx   • U R                   [        R                  L =(       d    U R                   [        S5      :H  $ )z;Return ``True`` if the left endpoint is negative infinity. z-inf)rý  r$   r×  r   rY   s    rG   Úis_left_unboundedÚInterval.is_left_unbounded  s+   € ð �y‰yœA×.Ñ.Ð.×L°$·)±)¼uÀV»}Ñ2LÐLrF   c                óx   • U R                   [        R                  L =(       d    U R                   [        S5      :H  $ )z<Return ``True`` if the right endpoint is positive infinity. z+inf)r   r$   r„   r   rY   s    rG   Úis_right_unboundedÚInterval.is_right_unbounded  s)   € ð �z‰zœQŸZ™ZÐ'×F¨4¯:©:¼¸v»Ñ+FÐFrF   c                óœ   • [        U[        5      (       d7  [        U[        5      (       a  [        $ [        U[        5      (       a  g [        $ g rD   )rº   rÃ   rÄ   r6   rJ   r‹   s     rG   Ú_eval_EqÚInterval._eval_Eq  s;   € Ü˜%¤×*Ñ*Ü˜%¤×+Ñ+Ü�Ü˜E¤3×'Ñ'ØÜˆLð +rF   rE   N)FF)é5   )#rê   rf  rg  rh  ri  ro  ra   rs  rØ  rÙ  rÚ  rÛ  Úclassmethodrì  rï  rò  rÔ   rÜ   rý  r   rP   rQ   rÉ   r  rã   r—  r  r  r!  r?  r'  r*  r-  r0  rv  rE   rF   rG   rÃ   rÃ     s—  † ñ(ðR €Kô&EðP ñó ðð  ñó ðð  ñó ðð  ñó ðð  ñ%ó ð%ð ñ&ó ð&ð ñ&ó ð&ð ñó ðð ñó ðð ñó ðð ñó ðð ñ ó ð ð ñ$ó ð$ò,ð ñ)ó ð)ò
4ò ð ñ%ó ð%ò#ô-òBòð ñMó ðMð ñGó ðGõrF   rÃ   c                  óæ   • \ rS rSrSrSr\S 5       r\S 5       rS r	\S 5       r
S r\S	 5       r\S
 5       r\S 5       r\S 5       r\S 5       rS r\S 5       rS rS rS r\S 5       rS rSrg)rŠ   i'  aÉ  
Represents a union of sets as a :class:`Set`.

Examples
========

>>> from sympy import Union, Interval
>>> Union(Interval(1, 2), Interval(3, 4))
Union(Interval(1, 2), Interval(3, 4))

The Union constructor will always try to merge overlapping intervals,
if possible. For example:

>>> Union(Interval(1, 2), Interval(2, 3))
Interval(1, 3)

See Also
========

Intersection

References
==========

.. [1] https://en.wikipedia.org/wiki/Union_%28set_theory%29
Tc                ó"   • [         R                  $ rD   ©r$   rš   rY   s    rG   ÚidentityÚUnion.identityD  ó   € ä�z‰zÐrF   c                ó"   • [         R                  $ rD   ©r$   ÚUniversalSetrY   s    rG   ÚzeroÚ
Union.zeroH  ó   € ä�~‰~ÐrF   c                óH  • UR                  S[        R                  5      n[        U5      nU(       a%  [	        U R                  U5      5      n[        U5      $ [	        [        U[        R                  5      5      n[        R                  " U /UQ76 n[        U5      Ul        U$ )Nr´   )Úgetr   r´   r*   r¾   Ú_new_args_filterÚsimplify_unionr%   rJ   r‡   r   ra   Ú	frozensetÚ_argset)r_   r`   rk   r´   Úobjs        rG   ra   ÚUnion.__new__L  sƒ   € Ø—:‘:˜jÔ*;×*DÑ*DÓEˆô ˜‹~ˆö Ü˜×,Ñ,¨TÓ2Ó3ˆDÜ! $Ó'Ð'ä”G˜D¤#×"2Ñ"2Ó3Ó4ˆä�mŠm˜CÐ' $Ò'ˆÜ “oˆŒØˆ
rF   c                ó   • U R                   $ rD   rÞ  rY   s    rG   r`   Ú
Union.args]  r÷  rF   c                óB   ^• [        U4S jU R                   5       5      $ )Nc              3  óD   >#   • U  H  oR                  T5      v •  M     g 7frD   ©r¦   )rª   r¬   r¥   s     €rG   r®   Ú$Union._complement.<locals>.<genexpr>c  s   øé € ÐFºI°qŸL™L¨×2Ð2ºIùó   ƒ )r‘   r`   r¤   s    `rG   rÉ   ÚUnion._complementa  s   ø€ äÔF¸D¿IºIÓFÓFÐFrF   c                ód   • [        U R                   Vs/ s H  oR                  PM     sn6 $ s  snf rD   )r0   r`   r~   ©rZ   r~  s     rG   rÔ   Ú
Union._infe  ó'   € ô ¨¯	ª	Ó2ª	 —W”W©	Ñ2Ð3Ð3ùÒ2ó   ”-c                ód   • [        U R                   Vs/ s H  oR                  PM     sn6 $ s  snf rD   )r/   r`   rÝ   rQ  s     rG   rÜ   Ú
Union._supk  rS  rT  c                ó:   • [        S U R                   5       5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r®  r¤  s     rG   r®   Ú!Union.is_empty.<locals>.<genexpr>s  s   é € Ð;²¨#Ÿž²ùr–  ©r   r`   rY   s    rG   rP   ÚUnion.is_emptyq  s   € äÑ;°·²Ó;Ó;Ð;rF   c                ó:   • [        S U R                   5       5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r³  r¤  s     rG   r®   Ú&Union.is_finite_set.<locals>.<genexpr>w  s   é € Ð@²i¨s×*Ö*²iùr–  rZ  rY   s    rG   rQ   ÚUnion.is_finite_setu  s   € äÑ@°d·i²iÓ@Ó@Ð@rF   c                ó´  ^ • T R                    Vs/ s H  n[        U5      U4PM     nnSnSnU(       a™  X4[        S U 5       5      -  -  nU 4S jU 5       nU VVs/ s H  u  pVUR                  S:w  d  M  XV4PM     nnn/ n/ nU H3  n	U	S   U;   a  M  UR	                  U	S   5        UR	                  U	5        M5     UnUS-  nU(       a  M™  U$ s  snf s  snnf )Nr   r²   c              3  ó>   #   • U  H  u  pUR                   v •  M     g 7frD   )r  )rª   ÚsosÚinters      rG   r®   Ú!Union._measure.<locals>.<genexpr>‹  s   é € Ð#IÂD±j°c E§M¦MÂDùs   ‚c              3  óœ   >#   • U  HA  u  pTR                     H+  nX1;  d  M
  U[        U5      -   UR                  U5      4v •  M-     MC     g 7frD   )r`   rÄ   r’   )rª   rb  r–   ÚnewsetrZ   s       €rG   r®   rd  �  sO   øé € ð *Ú-1Ñ)˜ÀÇ	Å	°fØÑ(ó N�Sœ9 VÓ,Ñ,¨f×.>Ñ.>¸|Ó.LÕMÙ@Iñ NÚ-1ùs
   ƒA¢*Aéÿÿÿÿ)r`   rÄ   Úsumr  rÂ   )
rZ   r¬   r½   r  Úparityrb  rc  Úsos_listÚ	sets_listÚ_sets
   `         rG   r  ÚUnion._measurey  sï   ø€ ð ,0¯9ª9Ó5ª9 a”˜1“˜qÓ!©9ˆÐ5ØˆØˆÞà¤Ñ#IÁDÓ#IÓ IÑIÑIˆGô*Ù-1ó*ˆDñ
 48ÔN²4¡Z S¸5¿=¹=ÈAÑ;M“L�S“L±4ˆDÑNð ˆHØˆIÛ�Ø˜‘7˜hÓ&Ùà—O‘O D¨¡GÔ,Ø×$Ñ$ TÖ*ñ ð ˆDð �b‰LˆF÷3 ˆdð4 ˆùò; 6ùó Os   �CÁCÁ6Cc                óº   ^• [        S U R                   5       5      mT(       d
  [        5       $ [        U4S jT 5       5      (       a  TS   $ [        [        5      $ )Nc              3  ób   #   • U  H%  o[         R                  Ld  M  UR                  v •  M'     g 7frD   )r$   rš   r  ©rª   r>  s     rG   r®   ÚUnion._kind.<locals>.<genexpr>¦  s   é € ÐMª) 3Ä!Ç*Á*Ð7L“h�c—h–hª)ùó   ‚/œ/c              3  ó2   >#   • U  H  oTS    :H  v •  M     g7f©r   NrE   ©rª   r«   Úkindss     €rG   r®   rq  ©  ó   øé € Ð.ª 1�e˜A‘h–ªùó   ƒr   )r  r`   r5  r€  r   ©rZ   rv  s    @rG   r  ÚUnion._kind¥  sG   ø€ ÜÑM¨$¯)ª)ÓMÓMˆÞÜ“9ÐÜÔ.©Ó.×.Ñ.Ø˜‘8ˆOäœ=Ó)Ð)rF   c           
     ól   ^ • U 4S jn[        [        U[        [        T R                  5      5      5      6 $ )Nc                ó    >• TR                   U    R                  n[        TR                   5       H  u  p#X :w  d  M  XR                  -
  nM     U$ )z7The boundary of set i minus interior of all other sets )r`   r  rÁ   r,  )r«   ræ   rœ  rž  rZ   s       €rG   Úboundary_of_setÚ(Union._boundary.<locals>.boundary_of_set°  sB   ø€ à—	‘	˜!‘×%Ñ%ˆAÜ! $§)¡)Ö,‘�Ø•6ØŸJ™J™’Añ -ð ˆHrF   )rŠ   ÚmaprÀ   r¼   r`   )rZ   r}  s   ` rG   r  ÚUnion._boundary®  s)   ø€ õ	ô ”c˜/¬5´°T·Y±Y³Ó+@ÓAÐBÐBrF   c                ón   • [        U R                   Vs/ s H  o"R                  U5      PM     sn6 $ s  snf rD   )r2   r`   r·   )rZ   rŒ   r¬   s      rG   rã   ÚUnion._contains¹  s*   € Ü¨t¯yªyÓ9ªy¨!—J‘J˜uÖ%©yÑ9Ð:Ð:ùÒ9ó   ”2c                óB   ^• [        U4S jU R                   5       5      $ )Nc              3  óD   >#   • U  H  oR                  T5      v •  M     g 7frD   rü   )rª   r¬   rŒ   s     €rG   r®   Ú"Union.is_subset.<locals>.<genexpr>½  s   øé € Ð?²Y°Ÿ™ U×+Ð+²YùrN  rZ  r‹   s    `rG   ró   ÚUnion.is_subset¼  ó   ø€ ÜÔ?°T·Y²YÓ?Ó?Ð?rF   c                ól  • [        U R                  5      S:X  aæ  [        S U R                   5       5      (       aÅ  U R                  u  p#UR                  UR                  :X  a�  UR
                  (       aŒ  UR                  (       a{  UR                  (       a  XR                  :„  OXR                  :¬  nUR
                  (       a  XR                  :  OXR                  :*  n[        XR                  5      n[        XdU5      $ [        U R                   Vs/ s H  owR                  U5      PM     sn6 $ s  snf )z<Rewrite a Union in terms of equalities and logic operators. rå  c              3  óB   #   • U  H  n[        U[        5      v •  M     g 7frD   )rº   rÃ   r”  s     rG   r®   Ú&Union.as_relational.<locals>.<genexpr>Â  s   é € Ð?²Y°”J˜q¤(×+Ð+²Yùr}  )r¼   r`   r€  rÝ   r~   rÛ  rÚ  r!   r1   r2   r—  )rZ   Úsymbolrž  ræ   ÚmincondÚmaxcondÚnecondr«   s           rG   r—  ÚUnion.as_relational¿  sÄ   € ä�—	‘	‹N˜aÓÜÑ?°T·Y²YÓ?×?Ñ?ð —9‘9‰DˆAØ�u‰u˜Ÿ™‹~ !§,§,°1·;·;Ø,-¯K¯K˜&§5¡5š.¸VÇuÁu¹_�Ø,-¯L¯L˜&§5¡5š.¸fÏÉ¹o�Ü˜F§E¡EÓ*�Ü˜6¨GÓ4Ð4Ü°T·Y²YÓ?²Y°—O‘O FÖ+±YÑ?Ð@Ð@ùÒ?s   ÄD1c                ó:   • [        S U R                   5       5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r£  rp  s     rG   r®   Ú$Union.is_iterable.<locals>.<genexpr>Ò  r¦  r–  ©r€  r`   rY   s    rG   rl  ÚUnion.is_iterableÐ  ó   € äÑ8¨d¯iªiÓ8Ó8Ð8rF   c                ó4   • [        S U R                   5       6 $ )Nc              3  ó8   #   • U  H  n[        U5      v •  M     g 7frD   ©Úiterrp  s     rG   r®   Ú!Union.__iter__.<locals>.<genexpr>Õ  s   é € Ð;²¨#œD ŸI˜I²ùr–  )r;   r`   rY   s    rG   rª  ÚUnion.__iter__Ô  s   € ÜÑ;°·²Ó;Ð<Ð<rF   rE   N)rê   rf  rg  rh  ri  rq  rs  r7  r=  ra   r`   rÉ   rÔ   rÜ   rP   rQ   r  r  r  rã   ró   r—  rl  rª  rv  rE   rF   rG   rŠ   rŠ   '  sÿ   † ñð4 €Hàñó ðð ñó ðòð" ñó ðòGð ñ4ó ð4ð
 ñ4ó ð4ð
 ñ<ó ð<ð ñAó ðAð ñ)ó ð)òV*ð ñCó ðCò;ò@òAð" ñ9ó ð9õ=rF   rŠ   c                  óÂ   • \ rS rSrSrSr\S 5       r\S 5       rSS.S jr	\S	 5       r
\S
 5       r\S 5       rS r\S 5       r\S 5       rS rS r\S 5       rS rSrg)r‘   iØ  aŒ  
Represents an intersection of sets as a :class:`Set`.

Examples
========

>>> from sympy import Intersection, Interval
>>> Intersection(Interval(1, 3), Interval(2, 4))
Interval(2, 3)

We often use the .intersect method

>>> Interval(1,3).intersect(Interval(2,4))
Interval(2, 3)

See Also
========

Union

References
==========

.. [1] https://en.wikipedia.org/wiki/Intersection_%28set_theory%29
Tc                ó"   • [         R                  $ rD   r;  rY   s    rG   r7  ÚIntersection.identityô  r?  rF   c                ó"   • [         R                  $ rD   r6  rY   s    rG   r=  ÚIntersection.zeroø  r9  rF   Nr³   c          	     ód  • Uc  [         R                  n[        [        [	        [        U5      5      5      5      nU(       a%  [        U R                  U5      5      n[        U5      $ [        [        U[        R                  5      5      n[        R                  " U /UQ76 n[        U5      Ul        U$ rD   )r   r´   r¾   r%   r~  r*   rB  Úsimplify_intersectionrJ   r‡   r   ra   rD  rE  )r_   r´   r`   rF  s       rG   ra   ÚIntersection.__new__ü  sŒ   € ØÑÜ(×1Ñ1ˆHô ”GœC¤¨£Ó/Ó0Ó1ˆö Ü˜×,Ñ,¨TÓ2Ó3ˆDÜ(¨Ó.Ð.ä”G˜D¤#×"2Ñ"2Ó3Ó4ˆä�mŠm˜CÐ' $Ò'ˆÜ “oˆŒØˆ
rF   c                ó   • U R                   $ rD   rÞ  rY   s    rG   r`   ÚIntersection.args  r÷  rF   c                ó:   • [        S U R                   5       5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r£  rp  s     rG   r®   Ú+Intersection.is_iterable.<locals>.<genexpr>  r¦  r–  )Úanyr`   rY   s    rG   rl  ÚIntersection.is_iterable  r–  rF   c                óH   • [        S U R                   5       5      (       a  gg )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r³  rp  s     rG   r®   Ú-Intersection.is_finite_set.<locals>.<genexpr>  s   é € Ð;²¨#×%Ö%²ùr–  T)r   r`   rY   s    rG   rQ   ÚIntersection.is_finite_set  s   € äÑ;°·²Ó;×;Ñ;Øð <rF   c                óº   ^• [        S U R                   5       5      mT(       d  [        [        5      $ [	        U4S jT 5       5      (       a  TS   $ [        5       $ )Nc              3  ób   #   • U  H%  o[         R                  Ld  M  UR                  v •  M'     g 7frD   )r$   r<  r  rp  s     rG   r®   Ú%Intersection._kind.<locals>.<genexpr>  s   é € ÐQª) 3Ä!Ç.Á.Ð7P“h�c—h–hª)ùrr  c              3  ó2   >#   • U  H  oTS    :H  v •  M     g7frt  rE   ru  s     €rG   r®   r²    rw  rx  r   )r  r`   r5  r   r€  ry  s    @rG   r  ÚIntersection._kind  sG   ø€ ÜÑQ¨$¯)ª)ÓQÓQˆÞÜœ=Ó)Ð)ÜÔ.©Ó.×.Ñ.Ø˜‘8ˆOä“9ÐrF   c                ó   • [        5       erD   rØ   rY   s    rG   rÔ   ÚIntersection._inf$  r0  rF   c                ó   • [        5       erD   rØ   rY   s    rG   rÜ   ÚIntersection._sup(  r0  rF   c                ón   • [        U R                   Vs/ s H  o"R                  U5      PM     sn6 $ s  snf rD   )r1   r`   r·   )rZ   rŒ   r~  s      rG   rã   ÚIntersection._contains,  s*   € Ü°D·I²IÓ>²I¨S—\‘\ %Ö(±IÑ>Ð?Ð?ùÒ>rƒ  c              #  ó(  #   • [        U R                  S 5      nSnUS   US    -   n/ / pTU H'  nS n [        U5      nUc  M  UR	                  U5        M)     UR                  [        S9  XE-    HG  n[        U R                  5      U1-
  n	[        U	SS06n
SnU H  n Xº;   a  Uv •  M  M     U(       d  MG    g    U(       d  U(       d  [        S5      e[        S5      eg ! [         a    UR	                  U5         N¾f = f! [         a    Sn Mu  f = f7f)Nc                ó   • U R                   $ rD   r£  ©r¸   s    rG   rH   Ú'Intersection.__iter__.<locals>.<lambda>0  s   € ¨a¯mªmrF   FT©Úkeyr´   z)None of the constituent sets are iterableziThe computation had not completed because of the undecidable set membership is found in every candidates.)r:   r`   r¼   r[  rÂ   Úsortr~  r‘   )rZ   Ú	sets_siftÚ	completedÚ
candidatesÚfinite_candidatesÚothersÚ	candidateÚlengthr¬   Ú
other_setsrŒ   r¸   s               rG   rª  ÚIntersection.__iter__/  s6  é € Ü˜Ÿ™Ñ$;Ó<ˆ	àˆ	Ø˜t‘_ y°¡Ñ6ˆ
à$&¨˜6Û#ˆIØˆFð)Ü˜Y›�ð Ó!Ø!×(Ñ(¨Ö3ñ $ð 	×Ñ¤3ÐÑ'à"Ô+ˆAÜ˜TŸY™Y›¨1¨#Ñ-ˆJÜ  *Ð=°uÑ=ˆEØˆIÛ�ð&Ø“zØœñ "ñ ÷ ˆyÙñ ,ö ÞÜÐ KÓLÐLÜðKóLð Lð øô) ó )Ø—‘˜iÖ(ð)ûô !ó &Ø %“Ið&üsX   ‚/D²C½DÁADÂ	C?Â&DÂ5)DÃC<Ã9DÃ;C<Ã<DÃ?DÄDÄDÄDc                óp  ^^• [        U S SS9u  pU(       d  gU Vs/ s H  n[        U5      PM     nn[        S U[        5       5      m[        5       nT HM  m[        U4S jU  5       5      nUSL a  UR	                  T5        Uc  M3  U H  nUR                  T5        M     MO     [        S U[        5       5      nU Vs/ s H  n[        U6 PM     n	nU(       a‹  U H{  m[        U4S jU	 5       5      n
U
SL a  UR	                  T5        U
c  M3  [        U5       H(  u  p·TU;   d  M  UR                  T5        [        U6 X›'   M*     UR                  T5          O   O	U(       a  M‹  [        U5      (       d  [        5       /nU(       a  U Vs/ s H  o3U-  PM	     nnU[        5       /:X  a  [        R                  $ U Vs/ s H  n[        U6 PM     nn[        S	 U[        5       5      mU4S
 jnU Vs/ s H  oí" U5      (       a  M  UPM     nnU(       ai  [        U6 nU[        R                  L a  [        R                  $ UR                  (       a  UR                  UR                  5        OUR!                  U5        [#        U5      S:X  a  US   $ [        USS06$ s  snf s  snf s  snf s  snf s  snf )z>Simplify intersection of one or more FiniteSets and other setsc                ó   • U R                   $ rD   )rn  r½  s    rG   rH   Ú2Intersection._handle_finite_sets.<locals>.<lambda>Z  s   € ¨q¯~ª~rF   T©ÚbinaryNc                ó
   • X-  $ rD   rE   rÆ  s     rG   rH   rÍ  b  ó   € ¨1ª5rF   c              3  óD   >#   • U  H  oR                  T5      v •  M     g 7frD   ©r·   ©rª   r¬   r�  s     €rG   r®   Ú3Intersection._handle_finite_sets.<locals>.<genexpr>h  s   øé € Ð:²T°Ÿj™j¨Ÿm˜m²TùrN  c                ó
   • X-  $ rD   rE   rÆ  s     rG   rH   rÍ  y  s   € ¨!ª%rF   c              3  óD   >#   • U  H  oR                  T5      v •  M     g 7frD   rÓ  rÔ  s     €rG   r®   rÕ  €  s   øé € Ð Cº
°1§¡¨A§ º
ùrN  c                ó
   • X-  $ rD   rE   rÆ  s     rG   rH   rÍ  £  rÑ  rF   c                ó0   >^ • [        U 4S jT 5       5      $ )Nc              3  óX   >#   • U  H  n[        TR                  U5      5      v •  M!     g 7frD   r¶   )rª   r�  r­   s     €rG   r®   ÚEIntersection._handle_finite_sets.<locals>.<lambda>.<locals>.<genexpr>¤  s!   øé € Ð$UÊÀ1¤Z°·
±
¸1³×%>Ð%>Êùs   ƒ'*)r€  )r­   Úall_elementss   `€rG   rH   rÍ  ¤  s   ù€ ¤Ô$UÉÓ$UÔ!UrF   r²   r   r´   F)r:   r~  r   r   ÚaddÚdiscardrÄ   rÁ   Úremover€  r$   rš   r‘   rM   Úextendr`   rÂ   r¼   )r`   Úfs_argsrÆ  ÚfsÚfs_setsÚdefiniteÚinallr¬   Úfs_elementsÚ
fs_symsetsÚinfsru   r½   Úis_redundantr­   ÚrestrÜ  r�  s                   @@rG   Ú_handle_finite_setsÚ Intersection._handle_finite_setsU  s_  ù€ ô
 ˜tÑ%=ÀdÑK‰ˆö Øñ &-Ó-¢W˜r”3�r–7¡WˆÐ-ÜÑ0°'¼3»5ÓAˆô “5ˆÛˆAÜÔ:±TÓ:Ó:ˆEØ˜Š}Ø—‘˜Q”ØÓ Û �AØ—I‘I˜a–Ló !ñ ô$ Ñ/°¼#»%Ó@ˆñ .5Ó5ªW¨”i “m©Wˆ
Ð5æÛ �Ü Ô C¹
Ó CÓC�Ø˜4’<Ø—L‘L ”OØÓ#Ü )¨'Ö 2™˜à �6ØŸH™H QœKÜ,5°q¨M˜J›Mñ	 !3ð
  ×&Ñ& qÔ)Ùñ !ð ÷! ˆkô( �7�|‰|Ü“u�gˆGö Ù/6Ó7ªw¨˜H”}©wˆGÐ7à”s“u�gÓÜ—:‘:Ðá'.Ó/¢w !”	˜1“¡wˆÐ/ô Ñ0°'¼3»5ÓAˆÜUˆÙ#Ó;šV˜¨<¸¯?—!™VˆÐ;æÜ Ð(ˆDð ”q—z‘zÒ!Ü—z‘zÐ!à×#×#Ø—‘˜DŸI™IÕ&à—‘˜DÔ!äˆt‹9˜‹>Ø˜‘7ˆNä Ð6°Ñ6Ð6ùòm .ùò6 6ùò< 8ùò
 0ùò <s#   �JÃJ$ÆJ)Ç J.Ç4J3ÈJ3c                ón   • [        U R                   Vs/ s H  o"R                  U5      PM     sn6 $ s  snf )zBRewrite an Intersection in terms of equalities and logic operators)r1   r`   r—  )rZ   rŒ  r~  s      rG   r—  ÚIntersection.as_relational¹  s,   € ä¸$¿)º)ÓDº)°3×&Ñ& vÖ.¹)ÑDÐEÐEùÒDrƒ  rE   )rê   rf  rg  rh  ri  rM   rs  r7  r=  ra   r`   rl  rQ   r  rÔ   rÜ   rã   rª  rt  rë  r—  rv  rE   rF   rG   r‘   r‘   Ø  sÑ   † ñð2 €Oàñó ðð ñó ðð '+õ ð$ ñó ðð ñ9ó ð9ð ñó ðòð ñ$ó ð$ð ñ$ó ð$ò@ò$LðL ña7ó ða7õFFrF   r‘   c                  ón   • \ rS rSrSrSrSS jr\S 5       rS r	S r
S r\S	 5       r\S
 5       rS rSrg)r£   i¾  ak  Represents the set difference or relative complement of a set with
another set.

$$A - B = \{x \in A \mid x \notin B\}$$


Examples
========

>>> from sympy import Complement, FiniteSet
>>> Complement(FiniteSet(0, 1, 2), FiniteSet(1))
{0, 2}

See Also
=========

Intersection, Union

References
==========

.. [1] https://mathworld.wolfram.com/ComplementSet.html
Tc                óŽ   • [        [        X45      u  pU(       a  [        R                  X5      $ [        R
                  " XU5      $ rD   )r  r*   r£   r   r   ra   ©r_   rž  ræ   r´   s       rG   ra   ÚComplement.__new__Ù  s7   € Ü”8˜a˜VÓ$‰ˆÞÜ×$Ñ$ QÓ*Ð*ä�}Š}˜S QÓ'Ð'rF   c                ó  ^ • U[         R                  :X  d  T R                  U5      (       a  [         R                  $ [	        U[
        5      (       a  [        U 4S jUR                   5       6 $ UR                  T 5      nUb  U$ [        T USS9$ )z"
Simplify a :class:`Complement`.

c              3  óD   >#   • U  H  oR                  T5      v •  M     g 7frD   rL  )rª   r¬   ÚAs     €rG   r®   Ú$Complement.reduce.<locals>.<genexpr>ê  s   øé € Ð!Bº6°a§,¡,¨q§/ /º6ùrN  Fr³   )
r$   r<  ró   rš   rº   rŠ   r‘   r`   rÉ   r£   ©rõ  ÚBÚresults   `  rG   r   ÚComplement.reduceà  sq   ø€ ð ”—‘Ó !§+¡+¨a§.¡.Ü—:‘:Ðä�aœ×ÑÜÔ!B¸1¿6º6Ó!BÐCÐCà—‘˜qÓ!ˆØÑØˆMä˜a ¨UÑ3Ð3rF   c                ó¤   • U R                   S   nU R                   S   n[        UR                  U5      [        UR                  U5      5      5      $ )Nr   r²   )r`   r1   r·   r3   )rZ   rŒ   rõ  rø  s       rG   rã   ÚComplement._containsò  s@   € Ø�I‰I�a‰LˆØ�I‰I�a‰LˆÜ�1—:‘:˜eÓ$¤c¨!¯*©*°UÓ*;Ó&<Ó=Ð=rF   c                óŠ   • U R                   u  p#UR                  U5      n[        UR                  U5      5      n[        XE5      $ )z?Rewrite a complement in terms of equalities and logic
operators)r`   r—  r3   r1   ©rZ   rŒ  rõ  rø  ÚA_relÚB_rels         rG   r—  ÚComplement.as_relational÷  s;   € ð �y‰y‰ˆà—‘ Ó'ˆÜ�A—O‘O FÓ+Ó,ˆä�5Ó Ð rF   c                ó4   • U R                   S   R                  $ ©Nr   )r`   r  rY   s    rG   r  ÚComplement._kind  s   € Ø�y‰y˜‰|× Ñ Ð rF   c                óB   • U R                   S   R                  (       a  gg )Nr   T)r`   rl  rY   s    rG   rl  ÚComplement.is_iterable  s   € à�9‰9�Q‰<×#×#Øð $rF   c                ót   • U R                   u  pUR                  nUSL a  gUSL a  UR                  (       a  gg g )NTF)r`   rQ   )rZ   rõ  rø  Úa_finites       rG   rQ   ÚComplement.is_finite_set	  s:   € à�y‰y‰ˆØ—?‘?ˆØ�tÒØØ˜Ò 1§?§?Øð $3ÐrF   c              #  óP   #   • U R                   u  pU H  nX2;  a  Uv •  M  M     g 7frD   r„  )rZ   rõ  rø  rž  s       rG   rª  ÚComplement.__iter__  s'   é € Ø�y‰y‰ˆÛˆAØ‹zØ”Gáò	 ùs   ‚$&rE   N©T)rê   rf  rg  rh  ri  rO   ra   rt  r   rã   r—  r  rs  rl  rQ   rª  rv  rE   rF   rG   r£   r£   ¾  sc   † ñð0 €Mô(ð ñ4ó ð4ò">ò
!ò!ð ñó ðð ñó ðõrF   r£   c                  óš   • \ rS rSrSrSrSrSr\\	" SSSS9S 5       5       r
\S	 5       rS
 rS rS rS rS r\S 5       rS rS rS rSrg)rš   i  aA  
Represents the empty set. The empty set is available as a singleton
as ``S.EmptySet``.

Examples
========

>>> from sympy import S, Interval
>>> S.EmptySet
EmptySet

>>> Interval(1, 2).intersect(S.EmptySet)
EmptySet

See Also
========

UniversalSet

References
==========

.. [1] https://en.wikipedia.org/wiki/Empty_set
TrR   rS   rT   rU   c                ó   • gr	  rE   rY   s    rG   r[   ÚEmptySet.is_EmptySet8  r]   rF   c                ó   • gr  rE   rY   s    rG   r  ÚEmptySet._measureD  ó   € àrF   c                ó   • [         $ rD   ©r6   r‹   s     rG   rã   ÚEmptySet._containsH  ó   € ÜˆrF   c                ó   • [         $ rD   r  ©rZ   rŒ  s     rG   r—  ÚEmptySet.as_relationalK  r  rF   c                ó   • gr  rE   rY   s    rG   rÊ  ÚEmptySet.__len__N  s   € ØrF   c                ó   • [        / 5      $ rD   r™  rY   s    rG   rª  ÚEmptySet.__iter__Q  s   € Ü�B‹xˆrF   c                ó   • [        U 5      $ rD   ©rÄ   rY   s    rG   r  ÚEmptySet._eval_powersetT  s   € Ü˜‹ÐrF   c                ó   • U $ rD   rE   rY   s    rG   r  ÚEmptySet._boundaryW  ó   € àˆrF   c                ó   • U$ rD   rE   r‹   s     rG   rÉ   ÚEmptySet._complement[  ó   € ØˆrF   c                ó   • [        5       $ rD   )r5  rY   s    rG   r  ÚEmptySet._kind^  s
   € Ü‹yÐrF   c                ó   • U$ rD   rE   r‹   s     rG   rÑ   ÚEmptySet._symmetric_differencea  r&  rF   rE   N)rê   rf  rg  rh  ri  rP   rQ   rn  rs  r7   r[   r  rã   r—  rÊ  rª  r  r  rÉ   r  rÑ   rv  rE   rF   rG   rš   rš     s”   † ñð0 €HØ€MØ€LàÙð	ð "'Ø#;ññóó ðð ñó ðòòòòòð ñó ðòòõrF   rš   )Ú	metaclassc                  ób   • \ rS rSrSrSrSrSrS rS r	\
S 5       rS rS	 rS
 r\
S 5       rSrg)r<  ie  ac  
Represents the set of all things.
The universal set is available as a singleton as ``S.UniversalSet``.

Examples
========

>>> from sympy import S, Interval
>>> S.UniversalSet
UniversalSet

>>> Interval(1, 2).intersect(S.UniversalSet)
Interval(1, 2)

See Also
========

EmptySet

References
==========

.. [1] https://en.wikipedia.org/wiki/Universal_set
TFc                ó"   • [         R                  $ rD   r6  r‹   s     rG   rÉ   ÚUniversalSet._complementƒ  s   € Ü�z‰zÐrF   c                ó   • U$ rD   rE   r‹   s     rG   rÑ   Ú"UniversalSet._symmetric_difference†  r&  rF   c                ó"   • [         R                  $ rD   )r$   r„   rY   s    rG   r  ÚUniversalSet._measure‰  r9  rF   c                ó    • [        [        5      $ rD   r4  rY   s    rG   r  ÚUniversalSet._kind�  r7  rF   c                ó   • [         $ rD   ©r5   r‹   s     rG   rã   ÚUniversalSet._contains�  ó   € ÜˆrF   c                ó   • [         $ rD   r6  r  s     rG   r—  ÚUniversalSet.as_relational“  r8  rF   c                ó"   • [         R                  $ rD   r6  rY   s    rG   r  ÚUniversalSet._boundary–  r9  rF   rE   N)rê   rf  rg  rh  ri  rN   rP   rQ   rÉ   rÑ   rs  r  r  rã   r—  r  rv  rE   rF   rG   r<  r<  e  sY   † ñð2 €OØ€HØ€Mòòð ñó ðò&òòð ñó órF   r<  c                  ó  ^ • \ 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
 5       r\S 5       r\S 5       r\S 5       rS rS rS rS rS rS r\S 5       rS rS rS rS rS rS rU 4S jr \!RD                  r"S\#S'   Sr$U =r%$ )rÄ   i›  a7  
Represents a finite set of Sympy expressions.

Examples
========

>>> from sympy import FiniteSet, Symbol, Interval, Naturals0
>>> FiniteSet(1, 2, 3, 4)
{1, 2, 3, 4}
>>> 3 in FiniteSet(1, 2, 3, 4)
True
>>> FiniteSet(1, (1, 2), Symbol('x'))
{1, x, (1, 2)}
>>> FiniteSet(Interval(1, 2), Naturals0, {1, 2})
FiniteSet({1, 2}, Interval(1, 2), Naturals0)
>>> members = [1, 2, 3, 4]
>>> f = FiniteSet(*members)
>>> f
{1, 2, 3, 4}
>>> f - FiniteSet(2)
{1, 3, 4}
>>> f + FiniteSet(2, 5)
{1, 2, 3, 4, 5}

References
==========

.. [1] https://en.wikipedia.org/wiki/Finite_set
TFc                ót  • UR                  S[        R                  5      nU(       a9  [        [	        [
        U5      5      n[        U5      S:X  a  [        R                  $ O[        [	        [
        U5      5      n0 n[        [        [        U5      5      5       H-  nUR                  (       a  XTU'   M   XTUR                  5       '   M/     [        UR                  5       5      n[        [        U[         R"                  5      5      n[$        R&                  " U /UQ76 nXgl        U$ ! [         a    XTU'    M�  f = f)Nr´   r   )rA  r   r´   r¾   r  r+   r¼   r$   rš   Úreversedr%   rŽ  Úas_dummyr[  r~  ÚvaluesrJ   r‡   r   ra   Ú	_args_set)r_   r`   rk   r´   Údargsr«   rB  rF  s           rG   ra   ÚFiniteSet.__new__¾  sø   € Ø—:‘:˜jÔ*;×*DÑ*DÓEˆÞÜœœG TÓ*Ó+ˆDä�4‹y˜A‹~Ü—z‘zÐ!ð ô œœG TÓ*Ó+ˆDð ˆÜœ$œw t›}Ó-Ö.ˆAØ�{�{Ø�a“ð!Ø*+˜!Ÿ*™*›,Ó'ñ /ô ˜Ÿ™›Ó'ˆ	Ü”G˜I¤s×'7Ñ'7Ó8Ó9ˆÜ�mŠm˜CÐ' $Ò'ˆØ!ŒØˆ
øô !ó !à ˜!”Hð!ús   Â4D%Ä%D7Ä6D7c                ó,   • [        U R                  5      $ rD   )rš  r`   rY   s    rG   rª  ÚFiniteSet.__iter__Ú  s   € Ü�D—I‘I‹ÐrF   c           	     óô  • [        U[        5      (       Gan  / / p2U R                   H[  nUR                  (       a$  UR                  (       a  UR                  U5        M8  UR                  S:X  a  MJ  UR                  U5        M]     U[        R                  :X  aË  U/ :w  aÅ  UR                  5         / nU[        [        R                  US   SS5      /-  n[        US S USS  5       H!  u  pgUR                  [        XgSS5      5        M#     UR                  [        US   [        R                  SS5      5        U/ :w  a  [        [        USS06[        U6 SS9$ [        USS06$ U/ :X  a  U(       a  [        U[        U6 SS9$ U$ Oà[        U[        5      (       aË  / nU  HX  n	[        UR!                  U	5      5      n
U
[        R"                  Ld  M2  U
[        R$                  Ld  MG  UR                  U	5        MZ     [        U6 nX€:X  a  g / nU HC  n	[        U R!                  U	5      5      n
U
[        R"                  Ld  M2  UR                  U	5        ME     [        [        U6 U5      $ [&        R)                  X5      $ )NFr   Trg  r²   r´   r³   )rº   rÃ   r`   rk  r  rÂ   r$   rÅ   rÁ  r×  r¿   r„   r£   rŠ   rÄ   r+   r·   r5   r6   rJ   rÉ   )rZ   rŒ   r  Úsymsr
  Ú	intervalsrž  ræ   Úunkr«   rå   Únot_trues               rG   rÉ   ÚFiniteSet._complementÝ  s  € Ü�eœX×&Ò&ð ˜R�$Ø—Y”Y�Ø—;—; 1§9§9Ø—K‘K –NØ—Y‘Y %Ó'Ùà—K‘K –Nñ ð œŸ™Ó D¨B£JØ—	‘	”Ø�	Øœh¤q×'9Ñ'9¸4À¹7ÀDÈ$ÓOÐPÑP�	Ü  S b 	¨4°°¨8Ö4‘D�AØ×$Ñ$¤X¨a°D¸$Ó%?Ö@ñ 5à× Ñ ¤¨$¨r©(´A·J±JÀÀdÓ!KÔLØ˜2“:Ü%¤e¨YÐ&GÀÑ&GÜ% tÐ,°uñ>ð >ô ! )Ð<°eÑ<Ð<Ø˜“ÞÜ% e¬Y¸Ð-=ÈÑNÐNà �Lð	 ô ˜œy×)Ñ)ØˆCÛ�Ü˜EŸN™N¨1Ó-Ó.�ØœAŸF™F”? q´·±Ô'7Ø—J‘J˜q–Mñ ô ˜S�/ˆCØ‹{ØØˆHÛ�Ü˜DŸM™M¨!Ó,Ó-�ØœAŸF™F”?Ø—O‘O AÖ&ñ ô œi¨Ð2°CÓ8Ð8ä�‰˜tÓ+Ð+rF   c                ó    • XR                   ;   a  [        R                  $ [        U R                   Vs/ s H  n[        X!SS9PM     sn6 $ s  snf )aK  
Tests whether an element, other, is in the set.

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

The actual test is for mathematical equality (as opposed to
syntactical equality). In the worst case all elements of the
set must be checked.

Examples
========

>>> from sympy import FiniteSet
>>> 1 in FiniteSet(1, 2)
True
>>> 5 in FiniteSet(1, 2)
False

Tr³   )rB  r$   r5   r2   r`   r    )rZ   rŒ   r�  s      rG   rã   ÚFiniteSet._contains  sA   € ð* —N‘NÓ"Ü—6‘6ˆMô ¸T¿YºYÓGºY¸œ˜1¨dÔ3¹YÑGÐHÐHùÒGs   ³Ac                óB   ^• [        U4S jU R                   5       5      $ )Nc              3  óF   >#   • U  H  nTR                  U5      v •  M     g 7frD   )rã   )rª   r�  rŒ   s     €rG   r®   Ú,FiniteSet._eval_is_subset.<locals>.<genexpr>+  s   øé € Ð?²Y°˜Ÿ™¨×+Ð+²Yùr°   rZ  r‹   s    `rG   rï   ÚFiniteSet._eval_is_subset*  rˆ  rF   c                ó   • U $ rD   rE   rY   s    rG   r  ÚFiniteSet._boundary-  r#  rF   c                ó   • [        U 6 $ rD   )r0   rY   s    rG   rÔ   ÚFiniteSet._inf1  ó   € ä�DˆzÐrF   c                ó   • [        U 6 $ rD   )r/   rY   s    rG   rÜ   ÚFiniteSet._sup5  rW  rF   c                ó   • gr  rE   rY   s    rG   r  ÚFiniteSet.measure9  r  rF   c                óä   ^ • T R                   (       d
  [        5       $ [        U 4S jT R                    5       5      (       a"  [        T R                   S   R                  5      $ [        [        5      $ )Nc              3  ón   >#   • U  H*  oR                   TR                  S    R                   :H  v •  M,     g7frt  ©r  r`   ©rª   r«   rZ   s     €rG   r®   Ú"FiniteSet._kind.<locals>.<genexpr>@  ó&   øé € Ð@²i°—‘˜4Ÿ9™9 Q™<×,Ñ,Ö,²iùó   ƒ25r   ©r`   r5  r€  r  r   rY   s   `rG   r  ÚFiniteSet._kind=  sK   ø€ Ø�y�yÜ“9ÐÜÔ@°d·i²iÓ@×@Ñ@Ü˜4Ÿ9™9 Q™<×,Ñ,Ó-Ð-äœ=Ó)Ð)rF   c                ó,   • [        U R                  5      $ rD   )r¼   r`   rY   s    rG   rÊ  ÚFiniteSet.__len__E  rÏ  rF   c           	     óP   • [        U  Vs/ s H  n[        X5      PM     sn6 $ s  snf )z@Rewrite a FiniteSet in terms of equalities and logic operators. )r2   r    )rZ   rŒ  Úelems      rG   r—  ÚFiniteSet.as_relationalH  s$   € ä±Ó6²¨”B�vÖ$±Ñ6Ð7Ð7ùÒ6s   Š#c                ó0   • [        U 5      [        U5      -
  $ rD   )Úhashr‹   s     rG   ÚcompareÚFiniteSet.compareL  s   € Ü�T“
œT %›[Ñ(Ð)rF   c           	     ól   • [        U5      n[        U  Vs/ s H  o3R                  US9PM     sn6 $ s  snf r9  )rB   rÄ   r{   )rZ   r<  r=  rh  s       rG   r?  ÚFiniteSet._eval_evalfO  s2   € Ü˜$ÓˆÜ¹Ó>º°Ÿ:™:¨˜:Ó,¹Ñ>Ð?Ð?ùÒ>s   •1c           
     óV   • SSK Jn  [        U  Vs/ s H  o2" U40 UD6PM     sn6 $ s  snf )Nr   )rr   )Úsympy.simplifyrr   rÄ   )rZ   rk   rr   rh  s       rG   Ú_eval_simplifyÚFiniteSet._eval_simplifyS  s,   € Ý+ÜÁÓEÂ¸˜8 DÑ3¨FÔ3ÁÑEÐFÐFùÒEs   �&c                ó   • U R                   $ rD   r„  rY   s    rG   Ú_sorted_argsÚFiniteSet._sorted_argsW  r†  rF   c                óŠ   • U R                   " [        U R                  5       Vs/ s H  oR                   " U6 PM     sn6 $ s  snf rD   )r;  r=   r`   )rZ   r¬   s     rG   r  ÚFiniteSet._eval_powerset[  s4   € Ø�yŠy´'¸$¿)¹)Ô2DÓEÒ2D¨QŸ9š9 a›=Ñ2DÑEÐFÐFùÒEs   ¤A c                ó  ^• SSK Jn  S nU" [        U 5      5      (       d  gS m[        U4S jU 5       5      (       d  g[	        U[        S9n[        UR                  5       H  n[        U6 nXq;  d  M    g   U" U5      $ )z1Rewriting method for a finite set to a power set.r²   r  c                ó>   • [        U =(       a    X S-
  -  (       + 5      $ r¼  )re  r:  s    rG   rH   Ú5FiniteSet._eval_rewrite_as_PowerSet.<locals>.<lambda>b  s   € œ4 × 5¨!°1©u©+¤oÔ6rF   Nc                óH   • [        U [        5      =(       a    U R                  $ rD   )rº   rJ   rn  )r>  s    rG   rH   r{  f  s   € œj¨¬cÓ2×G°s×7GÑ7GÐGrF   c              3  ó4   >#   • U  H  nT" U5      v •  M     g 7frD   rE   )rª   r>  Úfs_tests     €rG   r®   Ú6FiniteSet._eval_rewrite_as_PowerSet.<locals>.<genexpr>g  s   øé € Ð0ª4 C‘7˜3—<�<ª4ùs   ƒr¿  )r  r  r¼   r€  Úmaxr=   r`   rÄ   )	rZ   r`   rk   r  Úis2powÚbiggestr>  Úarg_setr~  s	           @rG   Ú_eval_rewrite_as_PowerSetÚ#FiniteSet._eval_rewrite_as_PowerSet^  st   ø€ å&á6ˆÙ”c˜$“i× Ñ ØáGˆÜÔ0©4Ó0×0Ñ0Øä�d¤Ñ$ˆÜ˜7Ÿ<™<Ö(ˆCÜ �oˆGØÕ"Ùñ )ñ ˜Ó Ð rF   c                ó|   • [        U[        5      (       d  [        S[        U5      -  5      eUR	                  U 5      $ ©Nz!Invalid comparison of set with %s©rº   rJ   r[  r>   ró   r‹   s     rG   Ú__ge__ÚFiniteSet.__ge__q  s4   € Ü˜%¤×%Ñ%ÜÐ?Ä)ÈEÓBRÑRÓSÐSØ�‰˜tÓ$Ð$rF   c                ó|   • [        U[        5      (       d  [        S[        U5      -  5      eU R	                  U5      $ r‡  )rº   rJ   r[  r>   r
  r‹   s     rG   Ú__gt__ÚFiniteSet.__gt__v  s6   € Ü˜%¤×%Ñ%ÜÐ?Ä)ÈEÓBRÑRÓSÐSØ×&Ñ& uÓ-Ð-rF   c                ó|   • [        U[        5      (       d  [        S[        U5      -  5      eU R	                  U5      $ r‡  rˆ  r‹   s     rG   Ú__le__ÚFiniteSet.__le__{  s4   € Ü˜%¤×%Ñ%ÜÐ?Ä)ÈEÓBRÑRÓSÐSØ�~‰~˜eÓ$Ð$rF   c                ó|   • [        U[        5      (       d  [        S[        U5      -  5      eU R	                  U5      $ r‡  )rº   rJ   r[  r>   r  r‹   s     rG   Ú__lt__ÚFiniteSet.__lt__€  s6   € Ü˜%¤×%Ñ%ÜÐ?Ä)ÈEÓBRÑRÓSÐSØ×$Ñ$ UÓ+Ð+rF   c                óv   >• [        U[        [        45      (       a  U R                  U:H  $ [        TU ]  U5      $ rD   )rº   r~  rD  rB  ÚsuperÚ__eq__)rZ   rŒ   Ú	__class__s     €rG   r–  ÚFiniteSet.__eq__…  s3   ø€ Ü�eœc¤9Ð-×.Ñ.Ø—>‘> UÑ*Ð*Ü‰w‰~˜eÓ$Ð$rF   zCallable[[Basic], Any]Ú__hash__rE   )&rê   rf  rg  rh  ri  rn  rl  rP   rQ   ra   rª  rÉ   rã   rï   rs  r  rÔ   rÜ   r  r  rÊ  r—  rl  r?  rr  ru  r  r„  r‰  rŒ  r�  r’  r–  r   r™  rj  rv  Ú__classcell__©r—  s   @rG   rÄ   rÄ   ›  sö   ø‡ ñð: €LØ€KØ€HØ€Mòò8ò/,òbIò8@ð ñó ðð ñó ðð ñó ðð ñó ðò*òò8ò*ò@òGð ñó ðòGò!ò&%ò
.ò
%ò
,õ
%ð
 ).¯©€HÐ%×6Ñ6rF   rÄ   c                ó   • [        U 6 $ rD   r  r½  s    rG   rH   rH   Œ  s   € ¤)¨Q¡-rF   c                ó   • [        U 6 $ rD   r  r½  s    rG   rH   rH   �  s   € ¬	°1©rF   c                  óR   • \ rS rSrSrSrSS jr\S 5       rS r	\
S 5       rS rS	rg
)rÍ   i�  al  Represents the set of elements which are in either of the
sets and not in their intersection.

Examples
========

>>> from sympy import SymmetricDifference, FiniteSet
>>> SymmetricDifference(FiniteSet(1, 2, 3), FiniteSet(3, 4, 5))
{1, 2, 4, 5}

See Also
========

Complement, Union

References
==========

.. [1] https://en.wikipedia.org/wiki/Symmetric_difference
Tc                óh   • U(       a  [         R                  X5      $ [        R                  " XU5      $ rD   )rÍ   r   r   ra   rñ  s       rG   ra   ÚSymmetricDifference.__new__¨  s'   € ÞÜ&×-Ñ-¨aÓ3Ð3ä�}Š}˜S QÓ'Ð'rF   c                óB   • UR                  U 5      nUb  U$ [        XSS9$ )NFr³   )rÑ   rÍ   r÷  s      rG   r   ÚSymmetricDifference.reduce®  s*   € à×(Ñ(¨Ó+ˆØÑØˆMä& q°eÑ<Ð<rF   c                óx   • U R                   u  p#UR                  U5      nUR                  U5      n[        XE5      $ )zIRewrite a symmetric_difference in terms of equalities and
logic operators)r`   r—  r4   rþ  s         rG   r—  Ú!SymmetricDifference.as_relational¶  s6   € ð �y‰y‰ˆà—‘ Ó'ˆØ—‘ Ó'ˆä�5Ó Ð rF   c                óH   • [        S U R                   5       5      (       a  gg )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r£  rp  s     rG   r®   Ú2SymmetricDifference.is_iterable.<locals>.<genexpr>Â  s   é € Ð4ª) 3�Žª)ùr–  Tr”  rY   s    rG   rl  ÚSymmetricDifference.is_iterableÀ  s   € äÑ4¨$¯)ª)Ó4×4Ñ4Øð 5rF   c              #  ó    #   • U R                   n[        S U 5       6 nU H)  nSnU H  nX5;   d  M
  US-  nM     US-  S:X  d  M%  Uv •  M+     g 7f)Nc              3  ó8   #   • U  H  n[        U5      v •  M     g 7frD   r™  rp  s     rG   r®   Ú/SymmetricDifference.__iter__.<locals>.<genexpr>È  s   é € Ð7²$¨3œT #ŸY˜Y²$ùr–  r   r²   rå  )r`   r;   )rZ   r`   r�   ÚitemÚcountr¬   s         rG   rª  ÚSymmetricDifference.__iter__Å  sW   é € à�y‰yˆÜÑ7±$Ó7Ð8ˆãˆDØˆEÛ�Ø•9Ø˜Q‘J’Eñ ð �q‰y˜A�~Ø”
ò ùs   ‚+A±AÁ	ArE   Nr  )rê   rf  rg  rh  ri  Úis_SymmetricDifferencera   rt  r   r—  rs  rl  rª  rv  rE   rF   rG   rÍ   rÍ   �  sF   † ñð* "Ðô(ð ñ=ó ð=ò!ð ñó ðõrF   rÍ   c                  ó|   • \ rS rSrSrS r\S 5       r\S 5       r\S 5       r	\S 5       r
S rS	 rS
 rS rS rSrg)ÚDisjointUnioniÕ  až  Represents the disjoint union (also known as the external disjoint union)
of a finite number of sets.

Examples
========

>>> from sympy import DisjointUnion, FiniteSet, Interval, Union, Symbol
>>> A = FiniteSet(1, 2, 3)
>>> B = Interval(0, 5)
>>> DisjointUnion(A, B)
DisjointUnion({1, 2, 3}, Interval(0, 5))
>>> DisjointUnion(A, B).rewrite(Union)
Union(ProductSet({1, 2, 3}, {0}), ProductSet(Interval(0, 5), {1}))
>>> C = FiniteSet(Symbol('x'), Symbol('y'), Symbol('z'))
>>> DisjointUnion(C, C)
DisjointUnion({x, y, z}, {x, y, z})
>>> DisjointUnion(C, C).rewrite(Union)
ProductSet({x, y, z}, {0, 1})

References
==========

https://en.wikipedia.org/wiki/Disjoint_union
c                ó²   • / nU H7  n[        U[        5      (       a  UR                  U5        M+  [        SU-  5      e   [        R
                  " U /UQ76 nU$ )NzQInvalid input: '%s', input args                     to DisjointUnion must be Sets)rº   rJ   rÂ   r[  r   ra   )r_   r½   Údj_collectionÚset_irF  s        rG   ra   ÚDisjointUnion.__new__ï  s`   € ØˆÛˆEÜ˜%¤×%Ñ%Ø×$Ñ$ UÖ+äð !3Ø5:ñ!;ó <ð <ñ	 ô �mŠm˜CÐ0 -Ò0ˆØˆ
rF   c                ó   • U R                   $ rD   r„  rY   s    rG   r½   ÚDisjointUnion.setsú  r†  rF   c                ó:   • [        S U R                   5       5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r®  r{  s     rG   r®   Ú)DisjointUnion.is_empty.<locals>.<genexpr> 	  s   é € Ð7ªY¨ŸžªYùr–  )r   r½   rY   s    rG   rP   ÚDisjointUnion.is_emptyþ  s   € äÑ7¨T¯YªYÓ7Ó7Ð7rF   c                óh   • [        S U R                   5       5      n[        U R                  U/5      $ )Nc              3  ó8   #   • U  H  oR                   v •  M     g 7frD   r³  r{  s     rG   r®   Ú.DisjointUnion.is_finite_set.<locals>.<genexpr>	  rµ  r–  r¶  r·  s     rG   rQ   ÚDisjointUnion.is_finite_set	  rº  rF   c                ó¤   • U R                   (       a  gSnU R                   H+  nUR                   (       a  M  U=(       a    UR                  nM-     U$ )NFT)rP   r½   rl  )rZ   Ú	iter_flagr´  s      rG   rl  ÚDisjointUnion.is_iterable	  s@   € à�=�=ØØˆ	Ø—Y”YˆEØ—>—>‘>Ø%×;¨%×*;Ñ*;’	ñ ð ÐrF   c                ó´   • [         R                  nSnU H?  n[        U[        5      (       d  M  [	        U[        U5      5      n[        X65      nUS-   nMA     U$ )z{
Rewrites the disjoint union as the union of (``set`` x {``i``})
where ``set`` is the element in ``sets`` at index = ``i``
r   r²   )r$   rš   rº   rJ   r»   rÄ   rŠ   )rZ   r½   rk   Údj_unionÚindexr´  Úcrosss          rG   Ú_eval_rewrite_as_UnionÚ$DisjointUnion._eval_rewrite_as_Union	  sT   € ô —:‘:ˆØˆÛˆEÜ˜%¤×%Ó%Ü" 5¬)°EÓ*:Ó;�Ü  Ó1�Ø ™	’ñ	 ð
 ˆrF   c                ód  • [        U[        5      (       a  [        U5      S:w  a  [        R                  $ US   R
                  (       d  [        R                  $ US   [        U R                  5      :¼  d	  US   S:  a  [        R                  $ U R                  US      R                  US   5      $ )a!  
``in`` operator for DisjointUnion

Examples
========

>>> from sympy import Interval, DisjointUnion
>>> D = DisjointUnion(Interval(0, 1), Interval(0, 2))
>>> (0.5, 0) in D
True
>>> (0.5, 1) in D
True
>>> (1.5, 0) in D
False
>>> (1.5, 1) in D
True

Passes operation on to constituent sets
rå  r²   r   )rº   r   r¼   r$   r6   rT  r½   rã   )rZ   r�  s     rG   rã   ÚDisjointUnion._contains 	  s„   € ô( ˜'¤5×)Ñ)¬S°«\¸QÓ->Ü—7‘7ˆNà�q‰z×$×$Ü—7‘7ˆNà�1‰:œ˜TŸY™Y›Ó'¨7°1©:¸«>Ü—7‘7ˆNà�y‰y˜ ™Ñ$×.Ñ.¨w°q©zÓ:Ð:rF   c                óÒ   ^ • T R                   (       d
  [        5       $ [        U 4S jT R                    5       5      (       a  T R                   S   R                  $ [        [        5      $ )Nc              3  ón   >#   • U  H*  oR                   TR                  S    R                   :H  v •  M,     g7frt  r^  r_  s     €rG   r®   Ú&DisjointUnion._kind.<locals>.<genexpr>B	  ra  rb  r   rc  rY   s   `rG   r  ÚDisjointUnion._kind?	  sF   ø€ Ø�y�yÜ“9ÐÜÔ@°d·i²iÓ@×@Ñ@Ø—9‘9˜Q‘<×$Ñ$Ð$äœ=Ó)Ð)rF   c           	     óì   • U R                   (       aV  / n[        U R                  5       H*  u  p#UR                  [	        U[        U5      15      5        M,     [        [        U6 5      $ [        SU -  5      e)Nz'%s' is not iterable.)	rl  rÁ   r½   rÂ   r9   r   rš  r;   rƒ   )rZ   Úitersr«   r¬   s       rG   rª  ÚDisjointUnion.__iter__G	  sa   € Ø××àˆEÜ! $§)¡)Ö,‘�Ø—‘œX a¬'°!«*¨Ó6Ö7ñ -ô œ
 EÐ*Ó+Ð+äÐ4°tÑ;Ó<Ð<rF   c                óŠ   • U R                   (       a%  SnU R                   H  nU[        U5      -  nM     U$ [        SU -  5      e)a¹  
Returns the length of the disjoint union, i.e., the number of elements in the set.

Examples
========

>>> from sympy import FiniteSet, DisjointUnion, EmptySet
>>> D1 = DisjointUnion(FiniteSet(1, 2, 3, 4), EmptySet, FiniteSet(3, 4, 5))
>>> len(D1)
7
>>> D2 = DisjointUnion(FiniteSet(3, 5, 7), EmptySet, FiniteSet(3, 5, 7))
>>> len(D2)
6
>>> D3 = DisjointUnion(EmptySet, EmptySet)
>>> len(D3)
0

Adds up the lengths of the constituent sets.
r   z'%s' is not a finite set.)rQ   r½   r¼   rƒ   )rZ   Úsizer~  s      rG   rÊ  ÚDisjointUnion.__len__R	  sD   € ð* ××ØˆDØ—y”y�Øœ˜C›Ñ ’ñ !àˆKäÐ8¸4Ñ?Ó@Ð@rF   rE   N)rê   rf  rg  rh  ri  ra   rs  r½   rP   rQ   rl  rÇ  rã   r  rª  rÊ  rv  rE   rF   rG   r±  r±  Õ  sv   † ñò2	ð ñó ðð ñ8ó ð8ð ñ5ó ð5ð ñó ðòò;ò>*ò	=õArF   r±  c            	     ó¨  ^• SSK Jn  SSKJn  [	        U 5      S:  a  [        S[	        U 5      -  5      e[        U S   [        [        45      (       a'  [	        U 5      S:”  a  [        U S   U S   5      nU SS nO
U S   nU SS n[        U[        5      (       a  GO[        U5      (       aæ  [        US0 5      nU(       ag  [	        U5      S:w  a  [        [        S	5      5      eUR                  S   nUS:X  a  S
nOL[        SUS-   5       Vs/ s H  n[        SU-  5      PM     nnO [         R"                  " U5      R$                  n['        U" U Vs/ s H  n[)        5       PM     sn6 5      m[        U4S jU 5       5      n	[        X“" U	6 5      nO [+        [        S[-        U5      -  5      5      e[/        S U 5       5      (       a)  U Vs/ s H  n[-        U5      PM     n
n[        SU
-  5      e[	        U5      S:X  Ga#  US   n U" X;5      nUc  [*        eU(       d  U$  [        XÁ5      (       a  UR                  u  p;UR0                  S   UR2                  :X  a  U$ [        X±5      (       a°  [	        UR4                  R0                  5      S:X  a�  [	        UR0                  5      S:X  at  UR4                  R0                  S   nUR0                  S   n[7        [        XÓR2                  R9                  XëR4                  R2                  5      5      /UR:                  Q76 $ Ub  U$ U" U/UQ76 $ s  snf s  snf s  snf ! [*         a    U" X;5      n GN/f = f)a"  
Return an image of the set under transformation ``f``.

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

If this function cannot compute the image, it returns an
unevaluated ImageSet object.

.. math::
    \{ f(x) \mid x \in \mathrm{self} \}

Examples
========

>>> from sympy import S, Interval, imageset, sin, Lambda
>>> from sympy.abc import x

>>> imageset(x, 2*x, Interval(0, 2))
Interval(0, 4)

>>> imageset(lambda x: 2*x, Interval(0, 2))
Interval(0, 4)

>>> imageset(Lambda(x, sin(x)), Interval(-2, 1))
ImageSet(Lambda(x, sin(x)), Interval(-2, 1))

>>> imageset(sin, Interval(-2, 1))
ImageSet(Lambda(x, sin(x)), Interval(-2, 1))
>>> imageset(lambda y: x + y, Interval(-2, 1))
ImageSet(Lambda(y, x + y), Interval(-2, 1))

Expressions applied to the set of Integers are simplified
to show as few negatives as possible and linear expressions
are converted to a canonical form. If this is not desirable
then the unevaluated ImageSet should be used.

>>> imageset(x, -2*x + 5, S.Integers)
ImageSet(Lambda(x, 2*x + 1), Integers)

See Also
========

sympy.sets.fancysets.ImageSet

r²   ©ÚImageSet)Úset_functionrå  z)imageset expects at least 2 args, got: %sr   NÚnargsz÷
                    This function can take more than 1 arg
                    but the potentially complicated set input
                    has not been analyzed at this point to
                    know its dimensions. TODO
                    r¸   zx%ic              3  óN   >#   • U  H  n[        [        U5      T5      v •  M     g 7frD   )r)   r'   )rª   r«   Údexprs     €rG   r®   Úimageset.<locals>.<genexpr>Á	  s+   øé € ð *Ú'( !ô *Ü�1‹I�u÷ð Ú'(ùs   ƒ"%zN
            expecting lambda, Lambda, or FunctionClass,
            not '%s'.c              3  óL   #   • U  H  n[        U[        5      (       + v •  M     g 7frD   rz  r{  s     rG   r®   rÜ  É	  s   é € Ð
4ª8 aŒz˜!œSÓ!×!Ñ!ª8ùrÂ  z.arguments after mapping should be sets, not %s)Ú	fancysetsr×  ÚsetexprrØ  r¼   rƒ   rº   r'   r  r   ÚcallableÚgetattrr€   r?   r`   rÀ   ÚinspectÚ	signatureÚ
parametersr*   r(   r[  r>   rª  Ú	variablesr…   ÚlamdaÚimagesetrg   Ú	base_sets)r`   r×  rØ  ÚfÚset_listrÙ  ÚNr¬   r«   ÚvarÚnamer~  Úrr¸   ÚyrÛ  s                  @rG   rç  rç  p	  s  ø€ õ^ $Ý%ä
ˆ4ƒy�1ƒ}ÜÐDÄsÈ4ÃyÑPÓQÐQä�$�q‘'œF¤E˜?×+Ñ+´°D³	¸A³Ü�4˜‘7˜D ™GÓ$ˆØ˜˜�8‰à�‰GˆØ˜˜�8ˆä�!”V×ÑÙÜ	�!�‰Ü˜˜7 BÓ'ˆÞÜ�5‹z˜Q‹Ü)¬*ð 6ó +ó ð ð —
‘
˜1‘ˆAØ�A‹vØ‘ä05°a¸¸Q¹´Ó@²¨1”V˜E A™IÖ&±�Ð@�ä×!Ò! !Ó$×/Ñ/ˆAä™©aÓ0ªa¨œUžW©aÑ0Ð1Ó2ˆÜô *Ù'(ó*ó *ˆä�3˜˜3˜Ó ‰äœ
ð $ä& q›\ñ$*ó +ó ,ð 	,ô Ñ
4©8Ó
4×4Ñ4Ù&.Ó/¢h ”	˜!–¡hˆÐ/ÜØ<¸tÑCóEð 	Eô ˆ8ƒ}˜ÔØ�q‰kˆð	!á˜QÓ$ˆAØ‰yÜ�ÞØ�ð ô �a×"Ñ"Ø—V‘V‰FˆAà�;‰;�q‰>˜QŸV™VÓ#ØˆJä�c×$Ñ$ô
 �3—9‘9×&Ñ&Ó'¨1Ó,´°Q·[±[Ó1AÀQÓ1FØ—I‘I×'Ñ'¨Ñ*�Ø—K‘K ‘N�ÜÜ˜1Ÿf™fŸk™k¨!¯Y©Y¯^©^Ó<Ó=ðOØ@CÇÁòOð Oð ‰=ØˆHá�AÐ!˜Ò!Ð!ùòc Aùò 1ùò 0øô ó 	!Ù˜Ó ‹Að	!ús$   Ä
L,ÅL1ÇL6ÈL; Ì;MÍMc                ó�   • U [         [        4;   a  g[        S5      nU " U5      R                  U5      nUS:„  S:X  d	  US:  S:X  a  gg)z_
Checks whether function ``func`` is invertible when the domain is
restricted to set ``setv``.
TÚur   N)r-   r.   r(   Údiff)r;  Úsetvrñ  Úfdiffs       rG   Úis_function_invertible_in_setrõ  ð	  sL   € ð ””SˆzÓØÜˆc‹
€AÙ�‹G�L‰L˜‹O€Eð 	�‰	�dÓ˜u q™y¨TÓ1ØàrF   c                óÂ  • SSK Jn  U (       d  [        R                  $ U  H#  n[	        U[
        5      (       a  M  [        S5      e   U  Vs/ s H  o3R                  (       d  M  UPM     nn[        U5      S:”  a:  S U 5       n[        U6 nU/U  Vs/ s H  o3R                  (       a  M  UPM     sn-   n [        U 5      n SnU(       ae  U  HV  nSnX1-
   H=  n	U" X‰5      n
U
c  M  [	        U
[        5      (       d  U
1n
XU	1-
  R                  U
5      n  O   U(       d  MT  Un   O   U(       a  Me  [        U 5      S:X  a  U R                  5       $ [        U SS06$ s  snf s  snf )	a:  
Simplify a :class:`Union` using known rules.

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

We first start with global rules like 'Merge all FiniteSets'

Then we iterate through all pairs and ask the constituent sets if they
can simplify themselves with any other constituent.  This process depends
on ``union_sets(a, b)`` functions.
r   )Ú
union_setsú Input args to Union must be Setsr²   c              3  ó6   #   • U  H  o  H  o"v •  M     M     g 7frD   rE   )rª   r~  r¸   s      rG   r®   Ú!simplify_union.<locals>.<genexpr>
  s   é € Ð3š+�3«s¨!ŒQ©s‰Qš+ùs   ‚TFr´   )Úsympy.sets.handlers.unionr÷  r$   rš   rº   rJ   r[  rn  r¼   rÄ   r~  r�   ÚpoprŠ   )r`   r÷  r>  r¸   Úfinite_setsrž  Ú
finite_setÚnew_argsr¬   ÚtÚnew_sets              rG   rC  rC  
  sK  € õ 5ö Ü�z‰zÐãˆÜ˜#œs×#Ó#ÜÐ>Ó?Ð?ñ ñ
 #Ó5šd˜§n¥n—1™d€KÐ5Ü
ˆ;Ó˜!ÓÙ3™+Ó3ˆÜ �]ˆ
Øˆ|©$ÓEª$ Q·nµnŸq©$ÑEÑEˆô ˆt‹9€DØ€HÞ
ÛˆAØˆHØ˜C”Z�Ù$ QÓ*�ð Ó&Ü% g¬s×3Ñ3Ø#* )˜Ø $¨1 v¡×4Ñ4°WÓ=�HÙñ  ÷ ˆxØ�Ùñ ÷ ˆ(ô  ˆ4ƒy�Aƒ~Ø�x‰x‹zÐä�dÐ+ UÑ+Ð+ùò; 6ùò Fs   ÁEÁ#EÂEÂ)Ec                óÄ  ^	• U (       d  [         R                  $ U  H#  n[        U[        5      (       a  M  [	        S5      e   [         R
                  U ;   a  [         R
                  $ [        R                  U 5      nUb  U$ U  Hl  nUR                  (       d  M  [        U 5      U1-
  n[        U5      S:”  a&  [        U6 m	[        U	4S jUR                   5       6 s  $ [        UR                  6 s  $    U  HX  nUR                  (       d  M  U R                  U5        XR                  S   /-   n[        [        U6 UR                  S   5      s  $    SSKJn  [        U 5      n SnU(       aN  U  H?  nSnX1-
   H&  nU" X75      nUc  M  XU1-
  R%                  U15      n  O   U(       d  M=  Un   O   U(       a  MN  [        U 5      S:X  a  U R'                  5       $ [        U SS06$ )	a)  
Simplify an intersection using known rules.

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

We first start with global rules like
'if any empty sets return empty set' and 'distribute any unions'

Then we iterate through all pairs and ask the constituent sets if they
can simplify themselves with any other constituent
rø  r   c              3  ó<   >#   • U  H  n[        UT5      v •  M     g 7frD   r�   )rª   r>  rŒ   s     €rG   r®   Ú(simplify_intersection.<locals>.<genexpr>`
  s   øé € ÐJÂ6¸Cœ|¨C°×7Ð7Â6ùs   ƒr²   )Úintersection_setsTFr´   )r$   r<  rº   rJ   r[  rš   r‘   rë  rq  r~  r¼   rŠ   r`   rO   rß  r£   Ú sympy.sets.handlers.intersectionr  r�   rü  )
r`   r>  Úrvr¬   rÉ  r  rÿ  r   r  rŒ   s
            @rG   r£  r£  :
  s´  ø€ ö Ü�~‰~ÐãˆÜ˜#œs×#Ó#ÜÐ>Ó?Ð?ñ ô
 	‡z�z�TÓÜ�z‰zÐô 
×	)Ñ	)¨$Ó	/€Bà	�~Øˆ	ó ˆØ�:�:‰:Ü˜T› a S™ˆJÜ�:‹ Ó"Ü$ jÐ1�ÜÔJÀ1Ç6Â6ÓJÐKÒKä˜aŸf™f�~Ò%ñ ó ˆØ�?�?‰?Ø�K‰K˜ŒNØ§¡¨¡ Ñ+ˆJÜœl¨JÐ7¸¿¹À¹ÓCÒCñ	 õ Cô ˆt‹9€DØ€HÞ
ÛˆAØˆHØ˜C”Z�Ù+¨AÓ1�ð Ó&Ø $¨1 v¡×4Ñ4°g°YÓ?�HÙñ  ÷ ˆxØ�Ùñ ÷ ˆ(ô ˆ4ƒy�Aƒ~Ø�x‰x‹zÐä˜TÐ2¨EÑ2Ð2rF   c                ó&  • [        X/S SS9u  pE[        U5      S:X  a/  [        US    VVs/ s H  odS     H
  op" Xg5      PM     M     snn6 $ [        U5      S:X  a*  US    Vs/ s H  n[        XS   Xc5      PM     nn[	        U6 $ g s  snnf s  snf )Nc                ó"   • [        U [        5      $ rD   )rº   rÄ   r½  s    rG   rH   Ú%_handle_finite_sets.<locals>.<lambda>Š
  s   € ¬J°q¼)Ô,DrF   TrÎ  rå  r   r²   )r:   r¼   rÄ   Ú_apply_operationrŠ   )	Úopr¸   rï  Úcommutativerá  rŒ   r«   rœ  r½   s	            rG   rë  rë  ˆ
  s”   € ä˜1˜&Ñ"DÈTÑR�N€GÜ
ˆ7ƒ|�qÓÜ¨W°QªZÔLªZ¨ÈÅ¸A˜2˜až8Á™8©ZÒLÐMÐMÜ	ˆW‹˜Ó	ØHOÐPQÊ
ÓSÊ
À1Ô  ¨1¡X¨qÖ>É
ˆÐSÜ�dˆ|Ðàùó MùâSs   ¬B
Á$Bc           	     ó  • SSK Jn  [        S5      n[        XX#5      nUc  U " X5      nUc  U(       a  U " X!5      nUcË  [	        S5      u  px[        U[        5      (       a=  [        U[        5      (       d(  U" [        XP" XR5      5      U5      R                  5       nU$ [        U[        5      (       d=  [        U[        5      (       a(  U" [        XP" X5      5      U5      R                  5       nU$ U" [        Xx4U " Xx5      5      X5      nU$ )Nr²   rÖ  r  zx y)	rÞ  r×  r(   rë  r&   rº   rJ   r   Údoit)	r  r¸   rï  r  r×  r  ÚoutÚ_xÚ_ys	            rG   r  r  ”
  sê   € Ý#Üˆc‹
€Aä
˜b QÓ
4€CØ
�{Ù�‹hˆà
�{–{Ù�‹hˆØ
�{Ü˜“‰ˆÜ�aœ×Ñ¤j°´C×&8Ñ&8Ùœ6 ! R¨£XÓ.°Ó2×7Ñ7Ó9ˆCð
 €Jô	 ˜Aœs×#Ñ#¬
°1´c×(:Ñ(:Ùœ6 ! R¨£XÓ.°Ó2×7Ñ7Ó9ˆCð €Jñ œ6 2 (©B¨r«JÓ7¸Ó>ˆCØ€JrF   c                ó$   • SSK Jn  [        X USS9$ )Nr   )Ú_set_addT©r  )Úsympy.sets.handlers.addr  r  )r¸   rï  r  s      rG   Úset_addr  ©
  ó   € Ý0Ü˜H¨¸Ñ=Ð=rF   c                ó$   • SSK Jn  [        X USS9$ )Nr   )Ú_set_subFr  )r  r  r  )r¸   rï  r  s      rG   Úset_subr  ®
  ó   € Ý0Ü˜H¨¸Ñ>Ð>rF   c                ó$   • SSK Jn  [        X USS9$ )Nr   )Ú_set_mulTr  )Úsympy.sets.handlers.mulr  r  )r¸   rï  r  s      rG   Úset_mulr   ³
  r  rF   c                ó$   • SSK Jn  [        X USS9$ )Nr   )Ú_set_divFr  )r  r"  r  )r¸   rï  r"  s      rG   Úset_divr#  ¸
  r  rF   c                ó$   • SSK Jn  [        X USS9$ )Nr   )Ú_set_powFr  )Úsympy.sets.handlers.powerr%  r  )r¸   rï  r%  s      rG   Úset_powr'  ½
  s   € Ý2Ü˜H¨¸Ñ>Ð>rF   c                ó   • SSK Jn  U" X5      $ )Nr   )Ú_set_function)Úsympy.sets.handlers.functionsr)  )ré  r¸   r)  s      rG   rØ  rØ  Â
  s   € Ý;Ù˜ÓÐrF   c                  ó6   ^ • \ rS rSrSrSU 4S jjrS rSrU =r$ )r5  iÇ
  a·  
SetKind is kind for all Sets

Every instance of Set will have kind ``SetKind`` parametrised by the kind
of the elements of the ``Set``. The kind of the elements might be
``NumberKind``, or ``TupleKind`` or something else. When not all elements
have the same kind then the kind of the elements will be given as
``UndefinedKind``.

Parameters
==========

element_kind: Kind (optional)
    The kind of the elements of the set. In a well defined set all elements
    will have the same kind. Otherwise the kind should
    :class:`sympy.core.kind.UndefinedKind`. The ``element_kind`` argument is optional but
    should only be omitted in the case of ``EmptySet`` whose kind is simply
    ``SetKind()``

Examples
========

>>> from sympy import Interval
>>> Interval(1, 2).kind
SetKind(NumberKind)
>>> Interval(1,2).kind.element_kind
NumberKind

See Also
========

sympy.core.kind.NumberKind
sympy.matrices.kind.MatrixKind
sympy.core.containers.TupleKind
c                ó2   >• [         TU ]  X5      nXl        U$ rD   )r•  ra   rÀ  )r_   rÀ  rF  r—  s      €rG   ra   ÚSetKind.__new__ë
  s   ø€ Ü‰g‰o˜cÓ0ˆØ'ÔØˆ
rF   c                óD   • U R                   (       d  gSU R                   -  $ )Nz	SetKind()zSetKind(%s))rÀ  rY   s    rG   Ú__repr__ÚSetKind.__repr__ð
  s   € Ø× × Øà  4×#4Ñ#4Ñ4Ð4rF   rE   rD   )	rê   rf  rg  rh  ri  ra   r/  rv  rš  r›  s   @rG   r5  r5  Ç
  s   ø† ñ"÷F÷
5ð 5rF   r5  )zÚ
__future__r   Útypingr   r   r   r   Ú	functoolsr   Úcollectionsr	   Úcollections.abcr
   r   râ  Úsympy.core.kindr   r   r   Úsympy.core.basicr   Úsympy.core.containersr   r   Úsympy.core.decoratorsr   r   Úsympy.core.evalfr   Úsympy.core.exprr   Úsympy.core.functionr   Úsympy.core.logicr   r   r   r   r   Úsympy.core.numbersr   r   Úsympy.core.operationsr   Úsympy.core.parametersr   Úsympy.core.relationalr    r!   r"   Úsympy.core.singletonr#   r$   Úsympy.core.sortingr%   Úsympy.core.symbolr&   r'   r(   r)   Úsympy.core.sympifyr*   r+   r,   Ú&sympy.functions.elementary.exponentialr-   r.   Ú(sympy.functions.elementary.miscellaneousr/   r0   Úsympy.logic.boolalgr1   r2   r3   r4   r5   r6   Úsympy.utilities.decoratorr7   Úsympy.utilities.exceptionsr8   Úsympy.utilities.iterablesr9   r:   r;   r<   r=   Úsympy.utilities.miscr>   r?   Úmpmathr@   rA   Úmpmath.libmp.libmpfrB   rä   rJ   r»   rÃ   rŠ   r‘   r£   rš   r<  rÄ   r~  rD  rÍ   r±  rç  rõ  rC  r£  rë  r  r  r  r   r#  r'  rØ  r5  rE   rF   rG   Ú<module>rO     sç  ðÝ "ç 9Ó 9Ý Ý #ß -Û ç ;Ñ ;Ý "ß 2ß EÝ 'Ý  Ý &÷õ ç -Ý +Ý 3ß /Ñ /ß -Ý &ß KÓ Kß BÑ Bß ;ß =ß >× >Ý 0Ý @÷0õ 0ç 6ç å +ñ ‘,Øˆ!�&‰&Ø‡F�FˆA�F‰FØ	ˆ1�7‰7Ø‡G�GˆQ�W‰Wð	!ó €ð ôcˆ%�ó có ðcôLr�ô rôjYˆsô Yôxn=ˆC�ô n=ôbcF�3˜	ô cFôLZ�ô ZôzGˆs˜iò GôT3�3 )ò 3ôlo7�ô o7ñb 0Ð �Ñ Ù5Ð �Ñ ôA˜#ô AôJXA�Cô XAòv}"ò@ò$5,òpK3ò\	òò*>ò
?ò
>ò
?ò
?ò
ô
-5ˆdõ -5rF   