ó
    ˆ*£hª.  ã            	      óÊ   • % S SK Jr  S SKJr  S SKJrJrJr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 jrS rS	 rS
 rS rS rS rS rS rS r\\\\\\\\S.rS\S'   g)é    )Úannotations)ÚCallable)ÚSÚAddÚExprÚBasicÚMulÚPowÚRational)Ú	fuzzy_not)ÚBoolean)ÚaskÚQc                óÜ  • [        U [        5      (       d  U $ U R                  (       d4  U R                   Vs/ s H  n[	        X!5      PM     nnU R
                  " U6 n [        U S5      (       a  U R                  U5      nUb  U$ U R                  R                  n[        R                  US5      nUc  U $ U" X5      nUb  X:X  a  U $ [        U[        5      (       d  U$ [	        Xq5      $ s  snf )a³  
Simplify an expression using assumptions.

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

Unlike :func:`~.simplify` which performs structural simplification
without any assumption, this function transforms the expression into
the form which is only valid under certain assumptions. Note that
``simplify()`` is generally not done in refining process.

Refining boolean expression involves reducing it to ``S.true`` or
``S.false``. Unlike :func:`~.ask`, the expression will not be reduced
if the truth value cannot be determined.

Examples
========

>>> from sympy import refine, sqrt, Q
>>> from sympy.abc import x
>>> refine(sqrt(x**2), Q.real(x))
Abs(x)
>>> refine(sqrt(x**2), Q.positive(x))
x

>>> refine(Q.real(x), Q.positive(x))
True
>>> refine(Q.positive(x), Q.real(x))
Q.positive(x)

See Also
========

sympy.simplify.simplify.simplify : Structural simplification without assumptions.
sympy.assumptions.ask.ask : Query for boolean expressions using assumptions.
Ú_eval_refineN)Ú
isinstancer   Úis_AtomÚargsÚrefineÚfuncÚhasattrr   Ú	__class__Ú__name__Úhandlers_dictÚgetr   )ÚexprÚassumptionsÚargr   Úref_exprÚnameÚhandlerÚnew_exprs           ÚU/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/assumptions/refine.pyr   r      sØ   € ôJ �dœE×"Ñ"Øˆà�<�<Ø48·I²IÓ>²I¨S”�sÖ(±IˆÐ>à�yŠy˜$ÐˆÜˆt�^×$Ñ$Ø×$Ñ$ [Ó1ˆØÑØˆOØ�>‰>×"Ñ"€DÜ×Ñ  dÓ+€GØ�ØˆÙ�tÓ)€HØÑ˜dÓ.ØˆÜ�h¤×%Ñ%ØˆÜ�(Ó(Ð(ùò! ?s   ·C)c                ó„  • SSK Jn  U R                  S   n[        [        R
                  " U5      U5      (       a0  [        [        [        R                  " U5      U5      5      (       a  U$ [        [        R                  " U5      U5      (       a  U* $ [        U[        5      (       a”  UR                   Vs/ s H  n[        [        U5      U5      PM     nn/ n/ nU HD  n[        X‚5      (       a   UR                  UR                  S   5        M3  UR                  U5        MF     [        U6 U" [        U6 5      -  $ gs  snf )a  
Handler for the absolute value.

Examples
========

>>> from sympy import Q, Abs
>>> from sympy.assumptions.refine import refine_abs
>>> from sympy.abc import x
>>> refine_abs(Abs(x), Q.real(x))
>>> refine_abs(Abs(x), Q.positive(x))
x
>>> refine_abs(Abs(x), Q.negative(x))
-x

r   ©ÚAbsN)Ú$sympy.functions.elementary.complexesr&   r   r   r   Úrealr   Únegativer   r	   r   ÚabsÚappend)	r   r   r&   r   ÚaÚrÚnon_absÚin_absÚis	            r#   Ú
refine_absr1   G   sõ   € õ" 9Ø
�)‰)�A‰,€CÜ
Œ1�6Š6�#‹;˜×$Ñ$Ü”cœ!Ÿ*š* S›/¨;Ó7×8Ñ8àˆ
Ü
Œ1�:Š:�c‹?˜K×(Ñ(Øˆtˆä�#”s×ÑØ25·(²(Ó;²(¨QŒV”C˜“F˜KÖ(±(ˆÐ;ØˆØˆÛˆAÜ˜!×!Ñ!Ø—‘˜aŸf™f Q™iÖ(à—‘˜qÖ!ñ	 ô
 �Gˆ}™s¤3¨ <Ó0Ñ0Ð0ð ùÚ;s   Â6D=c                ó`
  • SSK Jn  SSKJn  [	        U R
                  U5      (       a‘  [        [        R                  " U R
                  R                  S   5      U5      (       aU  [        [        R                  " U R                  5      U5      (       a&  U R
                  R                  S   U R                  -  $ [        [        R                  " U R
                  5      U5      (       GaF  U R
                  R                  (       aµ  [        [        R                  " U R                  5      U5      (       a"  [        U R
                  5      U R                  -  $ [        [        R                  " U R                  5      U5      (       a5  U" U R
                  5      [        U R
                  5      U R                  -  -  $ [	        U R                  [        5      (       ab  [	        U R
                  [         5      (       aC  [        U R
                  R
                  5      U R
                  R                  U R                  -  -  $ U R
                  ["        R$                  L GaÖ  U R                  R&                  (       Ga¹  U nU R                  R)                  5       u  pV[+        U5      n[+        5       n[+        5       n[-        U5      n	U Hs  n
[        [        R                  " U
5      U5      (       a  UR/                  U
5        M;  [        [        R                  " U
5      U5      (       d  Mb  UR/                  U
5        Mu     Xg-  n[-        U5      S-  (       a  Xh-  nU["        R0                  -   S-  nO	Xh-  nUS-  nXµ:w  d  [-        U5      U	:  a&  UR/                  U5        U R
                  [3        U6 -  n SU R                  -  n[        [        R                  " U5      U5      (       a#  UR5                  5       (       a  XÀR
                  -  nUR&                  (       Ga  UR7                  5       u  pÞUR8                  (       aï  UR
                  ["        R$                  L aÒ  [        [        R:                  " UR                  5      U5      (       a£  US-   S-  n[        [        R                  " U5      U5      (       a  U R
                  UR                  -  $ [        [        R                  " U5      U5      (       a  U R
                  UR                  S-   -  $ U R
                  UR                  U-   -  $ X@:w  a  U $ gggg)a  
Handler for instances of Pow.

Examples
========

>>> from sympy import Q
>>> from sympy.assumptions.refine import refine_Pow
>>> from sympy.abc import x,y,z
>>> refine_Pow((-1)**x, Q.real(x))
>>> refine_Pow((-1)**x, Q.even(x))
1
>>> refine_Pow((-1)**x, Q.odd(x))
-1

For powers of -1, even parts of the exponent can be simplified:

>>> refine_Pow((-1)**(x+y), Q.even(x))
(-1)**y
>>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z))
(-1)**y
>>> refine_Pow((-1)**(x+y+2), Q.odd(x))
(-1)**(y + 1)
>>> refine_Pow((-1)**(x+3), True)
(-1)**(x + 1)

r   r%   )Úsigné   é   N)r'   r&   Úsympy.functionsr3   r   Úbaser   r   r(   r   ÚevenÚexpÚ	is_numberr*   Úoddr   r
   r   ÚNegativeOneÚis_AddÚas_coeff_addÚsetÚlenÚaddÚOner   Úcould_extract_minus_signÚas_two_termsÚis_PowÚinteger)r   r   r&   r3   ÚoldÚcoeffÚtermsÚ
even_termsÚ	odd_termsÚinitial_number_of_termsÚtÚ	new_coeffÚe2r0   Úps                  r#   Ú
refine_PowrQ   m   s†  € õ8 9Ý$Ü�$—)‘)˜S×!Ñ!ÜŒq�vŠv�d—i‘i—n‘n QÑ'Ó(¨+×6Ñ6Ü”A—F’F˜4Ÿ8™8Ó$ k×2Ñ2Ø—9‘9—>‘> !Ñ$¨¯©Ñ0Ð0Ü
Œ1�6Š6�$—)‘)Ó˜k×*Ò*Ø�9‰9××Ü”1—6’6˜$Ÿ(™(Ó# [×1Ñ1Ü˜4Ÿ9™9“~¨¯©Ñ1Ð1Ü”1—5’5˜Ÿ™“? K×0Ñ0Ù˜DŸI™I“¬¨T¯Y©Y«¸4¿8¹8Ñ)CÑCÐCÜ�d—h‘h¤×)Ñ)Ü˜$Ÿ)™)¤S×)Ñ)Ü˜4Ÿ9™9Ÿ>™>Ó*¨t¯y©y¯}©}¸t¿x¹xÑ/GÑHÐHà�9‰9œŸ™Ó%Ø�x‰x��ˆà�ð  $Ÿx™x×4Ñ4Ó6‘�Ü˜E›
�Ü ›U�
Ü›E�	Ü*-¨e«*Ð'ã�AÜœ1Ÿ6š6 !›9 k×2Ñ2Ø"Ÿ™ qÖ)ÜœQŸUšU 1›X {×3Ó3Ø!Ÿ™ aÖ(ñ	 ð Ñ#�Ü�y“> A×%ØÑ&�EØ!&¬¯©¡°!Ñ 3‘IàÑ&�EØ %¨¡	�IàÓ%¬¨U«Ð6MÓ)MØ—I‘I˜iÔ(ØŸ9™9¤s¨E {Ñ3�Dð �t—x‘x‘Z�Ü”q—v’v˜b“z ;×/Ñ/Ø×2Ñ2×4Ñ4ØŸi™i™˜Ø—9—9�9ØŸ?™?Ó,‘D�AØ—x—x A§F¡F¬a¯m©mÒ$;ÜœqŸyšy¨¯©Ó/°×=Ñ=Ø!" Q¡¨¡	˜AÜ"¤1§6¢6¨!£9¨k×:Ñ:Ø'+§y¡y°!·%±%Ñ'7Ð 7Ü!$¤Q§U¢U¨1£X¨{×!;Ñ!;Ø'+§y¡y°1·5±5¸1±9Ñ'=Ð =à'+§y¡y°1·5±5¸1±9Ñ'=Ð =à“;Ø�Kð ðg ð &ð +ó    c                ó„  • SSK Jn  U R                  u  p4[        [        R
                  " U5      [        R                  " U5      -  U5      (       a
  U" X4-  5      $ [        [        R                  " U5      [        R                  " U5      -  U5      (       a  U" X4-  5      [        R                  -
  $ [        [        R                  " U5      [        R                  " U5      -  U5      (       a  U" X4-  5      [        R                  -   $ [        [        R                  " U5      [        R                  " U5      -  U5      (       a  [        R                  $ [        [        R                  " U5      [        R                  " U5      -  U5      (       a  [        R                  S-  $ [        [        R                  " U5      [        R                  " U5      -  U5      (       a  [        R                  * S-  $ [        [        R                  " U5      [        R                  " U5      -  U5      (       a  [        R                  $ U $ )ao  
Handler for the atan2 function.

Examples
========

>>> from sympy import Q, atan2
>>> from sympy.assumptions.refine import refine_atan2
>>> from sympy.abc import x, y
>>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x))
atan(y/x)
>>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x))
atan(y/x) - pi
>>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x))
atan(y/x) + pi
>>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x))
pi
>>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x))
pi/2
>>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x))
-pi/2
>>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x))
nan
r   )Úatanr4   )Ú(sympy.functions.elementary.trigonometricrT   r   r   r   r(   Úpositiver)   r   ÚPiÚzeroÚNaN)r   r   rT   ÚyÚxs        r#   Úrefine_atan2r\   Ñ   si  € õ2 >Ø�9‰9�D€AÜ
Œ1�6Š6�!‹9”q—z’z !“}Ñ$ k×2Ñ2Ù�A‘E‹{ÐÜ	ŒQ�ZŠZ˜‹]œQŸZšZ¨›]Ñ*¨K×	8Ñ	8Ù�A‘E‹{œQŸT™TÑ!Ð!Ü	ŒQ�ZŠZ˜‹]œQŸZšZ¨›]Ñ*¨K×	8Ñ	8Ù�A‘E‹{œQŸT™TÑ!Ð!Ü	ŒQ�VŠV�A‹YœŸš A›Ñ&¨×	4Ñ	4Ü�t‰tˆÜ	ŒQ�ZŠZ˜‹]œQŸVšV A›YÑ&¨×	4Ñ	4Ü�t‰t�A‰vˆÜ	ŒQ�ZŠZ˜‹]œQŸVšV A›YÑ&¨×	4Ñ	4Ü—‘ˆu�Q‰wˆÜ	ŒQ�VŠV�A‹YœŸš ›Ñ" K×	0Ñ	0Ü�u‰uˆàˆrR   c                óî   • U R                   S   n[        [        R                  " U5      U5      (       a  U$ [        [        R                  " U5      U5      (       a  [
        R                  $ [        X5      $ )zà
Handler for real part.

Examples
========

>>> from sympy.assumptions.refine import refine_re
>>> from sympy import Q, re
>>> from sympy.abc import x
>>> refine_re(re(x), Q.real(x))
x
>>> refine_re(re(x), Q.imaginary(x))
0
r   )r   r   r   r(   Ú	imaginaryr   ÚZeroÚ_refine_reim©r   r   r   s      r#   Ú	refine_rerb   þ   sU   € ð �)‰)�A‰,€CÜ
Œ1�6Š6�#‹;˜×$Ñ$Øˆ
Ü
Œ1�;Š;�sÓ˜[×)Ñ)Ü�v‰vˆÜ˜Ó*Ð*rR   c                ó  • U R                   S   n[        [        R                  " U5      U5      (       a  [        R
                  $ [        [        R                  " U5      U5      (       a  [        R                  * U-  $ [        X5      $ )zî
Handler for imaginary part.

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

>>> from sympy.assumptions.refine import refine_im
>>> from sympy import Q, im
>>> from sympy.abc import x
>>> refine_im(im(x), Q.real(x))
0
>>> refine_im(im(x), Q.imaginary(x))
-I*x
r   )	r   r   r   r(   r   r_   r^   ÚImaginaryUnitr`   ra   s      r#   Ú	refine_imre     sb   € ð �)‰)�A‰,€CÜ
Œ1�6Š6�#‹;˜×$Ñ$Ü�v‰vˆÜ
Œ1�;Š;�sÓ˜[×)Ñ)Ü—‘Ð  3Ñ&Ð&Ü˜Ó*Ð*rR   c                óö   • U R                   S   n[        [        R                  " U5      U5      (       a  [        R
                  $ [        [        R                  " U5      U5      (       a  [        R                  $ g)zö
Handler for complex argument

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

>>> from sympy.assumptions.refine import refine_arg
>>> from sympy import Q, arg
>>> from sympy.abc import x
>>> refine_arg(arg(x), Q.positive(x))
0
>>> refine_arg(arg(x), Q.negative(x))
pi
r   N)r   r   r   rV   r   r_   r)   rW   )r   r   Úrgs      r#   Ú
refine_argrh   +  sP   € ð 
�‰�1‰€BÜ
Œ1�:Š:�b‹>˜;×'Ñ'Ü�v‰vˆÜ
Œ1�:Š:�b‹>˜;×'Ñ'Ü�t‰tˆØrR   c                óP   • U R                  SS9nX :w  a  [        X!5      nX2:w  a  U$ g )NT)Úcomplex)Úexpandr   )r   r   ÚexpandedÚrefineds       r#   r`   r`   B  s0   € à�{‰{ Tˆ{Ð*€HØÓÜ˜Ó/ˆØÓØˆNàrR   c                óì  • U R                   S   n[        [        R                  " U5      U5      (       a  [        R
                  $ [        [        R                  " U5      5      (       aj  [        [        R                  " U5      U5      (       a  [        R                  $ [        [        R                  " U5      U5      (       a  [        R                  $ [        [        R                  " U5      5      (       a}  UR                  5       u  p4[        [        R                  " U5      U5      (       a  [        R                  $ [        [        R                  " U5      U5      (       a  [        R                  * $ U $ )aÚ  
Handler for sign.

Examples
========

>>> from sympy.assumptions.refine import refine_sign
>>> from sympy import Symbol, Q, sign, im
>>> x = Symbol('x', real = True)
>>> expr = sign(x)
>>> refine_sign(expr, Q.positive(x) & Q.nonzero(x))
1
>>> refine_sign(expr, Q.negative(x) & Q.nonzero(x))
-1
>>> refine_sign(expr, Q.zero(x))
0
>>> y = Symbol('y', imaginary = True)
>>> expr = sign(y)
>>> refine_sign(expr, Q.positive(im(y)))
I
>>> refine_sign(expr, Q.negative(im(y)))
-I
r   )r   r   r   rX   r   r_   r(   rV   rB   r)   r<   r^   Úas_real_imagrd   )r   r   r   Úarg_reÚarg_ims        r#   Úrefine_signrr   M  së   € ð0 �)‰)�A‰,€CÜ
Œ1�6Š6�#‹;˜×$Ñ$Ü�v‰vˆÜ
Œ1�6Š6�#‹;×ÑÜŒq�zŠz˜#‹ ×,Ñ,Ü—5‘5ˆLÜŒq�zŠz˜#‹ ×,Ñ,Ü—=‘=Ð Ü
Œ1�;Š;�sÓ×ÑØ×)Ñ)Ó+‰ˆÜŒq�zŠz˜&Ó! ;×/Ñ/Ü—?‘?Ð"ÜŒq�zŠz˜&Ó! ;×/Ñ/Ü—O‘OÐ#Ð#Ø€KrR   c                ó¼   • SSK Jn  U R                  u  p4n[        [        R
                  " U5      U5      (       a"  XE-
  R                  5       (       a  U $ U" X5U5      $ g)a)  
Handler for symmetric part.

Examples
========

>>> from sympy.assumptions.refine import refine_matrixelement
>>> from sympy import MatrixSymbol, Q
>>> X = MatrixSymbol('X', 3, 3)
>>> refine_matrixelement(X[0, 1], Q.symmetric(X))
X[0, 1]
>>> refine_matrixelement(X[1, 0], Q.symmetric(X))
X[0, 1]
r   )ÚMatrixElementN)Ú"sympy.matrices.expressions.matexprrt   r   r   r   Ú	symmetricrC   )r   r   rt   Úmatrixr0   Újs         r#   Úrefine_matrixelementry   v  sS   € õ AØ—9‘9�L€FˆqÜ
Œ1�;Š;�vÓ ×,Ñ,Ø‰E×+Ñ+×-Ñ-ØˆKÙ˜V¨Ó*Ð*ð -rR   )r&   r
   Úatan2ÚreÚimr   r3   rt   z*dict[str, Callable[[Expr, Boolean], Expr]]r   N)T)Ú
__future__r   Útypingr   Ú
sympy.corer   r   r   r   r	   r
   r   Úsympy.core.logicr   Úsympy.logic.boolalgr   Úsympy.assumptionsr   r   r   r1   rQ   r\   rb   re   rh   r`   rr   ry   r   Ú__annotations__© rR   r#   Ú<module>r…      s~   ðÞ "Ý ç >× >Ñ >Ý &Ý 'ç $ô9)òx#1òLa òH*òZ+ò.+ò,ò.ò&òR+ð. ØØØ
Ø
ØØØ)ñ	=€Ð9ô 	rR   