
    \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           P/var/www/auris/envauris/lib/python3.13/site-packages/sympy/assumptions/refine.pyr   r      s    J dE""<<48II>ISs(I>yy$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[        X5      (       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
166#;$$c!**S/;788

1::c?K((t#s25((;(QVCFK((;A!!!affQi(q!	 
 G}s3<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  XR
                  -  nUR&                  (       Ga  UR7                  5       u  pU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!!qvvdiinnQ'(+66AFF488$k2299>>!$00
166$))k**99166$((#[11499~11155?K00DIITYY488)CCCdhh))$))S))499>>*tyy}}txx/GHH99%xx  $xx446E
 U
E	*-e*'A166!9k22"q)QUU1X{33!a(	  #y>A%&E!&! 3I&E %	I%U6M)MIIi(99sE{3D txxZqvvbz;//2244ii999??,DAxxAFFamm$;qyy/==!"Q	A"166!9k::'+yy!%%'7 7!$QUU1X{!;!;'+yy15519'= ='+yy15519'= =;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 >99DA
166!9qzz!}$k22AE{	QZZ]QZZ]*K	8	8AE{QTT!!	QZZ]QZZ]*K	8	8AE{QTT!!	QVVAYA&	4	4tt	QZZ]QVVAY&	4	4ttAv	QZZ]QVVAY&	4	4uQw	QVVAY"K	0	0uu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
166#;$$

1;;s[))vv**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
166#;$$vv
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>;''vv
1::b>;''tt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
166#;$$vv
166#;qzz#,,55Lqzz#,,== 
1;;s))+qzz&!;//??"qzz&!;//OO##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99LFq
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#1La H*Z+.+,.&R+. 

)	=9 	rR   