
    Ed.              	           d dl mZmZ d dlmZmZmZmZm	Z	m
Z
mZ d dlmZ d dlmZ d dlmZmZ ddZd Zd	 Zd
 Zd Zd Zd Zd Zd Zd ZeeeeeeeedZdS )    )DictCallable)SAddExprBasicMulPowRational)	fuzzy_not)Boolean)askQTc                    t          | t                    s| S | j        sfd| j        D             } | j        | } t          | d          r|                               }||S | j        j        }t          
                    |d          }|| S  ||           }|| |k    r| S t          |t                    s|S t          |          S )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.
    c                 0    g | ]}t          |          S  )refine).0argassumptionss     8lib/python3.11/site-packages/sympy/assumptions/refine.py
<listcomp>zrefine.<locals>.<listcomp>3   s#    >>>SsK((>>>    _eval_refineN)
isinstancer   is_Atomargsfunchasattrr   	__class____name__handlers_dictgetr   r   )exprr   r   ref_exprnamehandlernew_exprs    `     r   r   r   
   s    J dE"" <  >>>>DI>>>ty$t^$$ $$[11 	O>"Dd++G wt[))H dh. h%% (K(((r   c                 D   ddl m} | j        d         }t          t	          j        |                    r1t          t          t	          j        |                              r|S t          t	          j        |                    r| S t          |t                    r~fd|j        D             }g }g }|D ]H}t          ||          r!|
                    |j        d                    3|
                    |           It          |  |t          |           z  S dS )aF  
    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   Absc                 J    g | ]}t          t          |                     S r   )r   abs)r   ar   s     r   r   zrefine_abs.<locals>.<listcomp>a   s)    ;;;QVCFFK((;;;r   N)$sympy.functions.elementary.complexesr+   r   r   r   realr   negativer   r	   append)r$   r   r+   r   rnon_absin_absis    `      r   
refine_absr7   F   s5   " 988888
)A,C
16#;;$$ c!*S//;7788 

1:c??K(( t#s 	1;;;;#(;;; 	" 	"A!S!! "afQi((((q!!!!G}ss3<0000	1 	1r   c                    ddl m} ddlm} t	          | j        |          rst          t          j        | j        j	        d                   |          rAt          t          j
        | j                  |          r| j        j	        d         | j        z  S t          t          j        | j                  |          r| j        j        rt          t          j
        | j                  |          rt          | j                  | j        z  S t          t          j        | j                  |          r- || j                  t          | j                  | j        z  z  S t	          | j        t                    rHt	          | j        t                     r.t          | j        j                  | j        j        | j        z  z  S | j        t"          j        u r| j        j        rx| }| j                                        \  }}t+          |          }t+                      }t+                      }t-          |          }	|D ]q}
t          t          j
        |
          |          r|                    |
           :t          t          j        |
          |          r|                    |
           r||z  }t-          |          dz  r||z  }|t"          j        z   dz  }n
||z  }|dz  }||k    st-          |          |	k     r&|                    |           | j        t3          | z  } d| j        z  }t          t          j
        |          |          r|                                r
|| j        z  }|j        r|                                \  }}|j        r|j        t"          j        u rt          t          j        |j                  |          r|dz   dz  }t          t          j
        |          |          r| j        |j        z  S t          t          j        |          |          r| j        |j        dz   z  S | j        |j        |z   z  S || k    r| S dS dS dS dS )as  
    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.functionsr9   r   baser   r   r0   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+   r9   oldcoeffterms
even_terms	odd_termsinitial_number_of_termst	new_coeffe2r6   ps                  r   
refine_PowrW   l   s*   8 988888$$$$$$$)S!! 1qvdinQ'((+66 	1AF48$$k22	19>!$00
16$)k** ? 9 	D16$(##[11 249~~1115??K00 DtDITY48)CCCdh)) 	I$)S)) I49>**ty}tx/GHH9% 5	 x 4   $x4466uE

 UU
EE	*-e**' ) )A16!99k22 )"q))))QU1XX{33 )!a(((#y>>A% *Y&E!&! 3IIY&E %	I% 4U6M)M 4IIi(((9sE{3D txZqvbzz;// (2244 (di9 
>??,,DAqx >AFam$; >qy//== >!"Q	A"16!99k:: >'+y!%'7 7!$QU1XX{!;!; >'+y1519'= ='+y1519'= =$;  K?  ? 5	  5	 4  4 f   r   c                    ddl m} | j        \  }}t          t	          j        |          t	          j        |          z  |          r |||z            S t          t	          j        |          t	          j        |          z  |          r |||z            t          j	        z
  S t          t	          j        |          t	          j        |          z  |          r |||z            t          j	        z   S t          t	          j
        |          t	          j        |          z  |          rt          j	        S t          t	          j        |          t	          j
        |          z  |          rt          j	        dz  S t          t	          j        |          t	          j
        |          z  |          rt          j	         dz  S t          t	          j
        |          t	          j
        |          z  |          rt          j        S | S )a  
    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   )atanr:   )(sympy.functions.elementary.trigonometricrY   r   r   r   r0   positiver1   r   PizeroNaN)r$   r   rY   yxs        r   refine_atan2ra      s   2 >=====9DAq
16!99qz!}}$k22 tAE{{	QZ]]QZ]]*K	8	8 tAE{{QT!!	QZ]]QZ]]*K	8	8 tAE{{QT!!	QVAYYA&	4	4 	t	QZ]]QVAYY&	4	4 tAv	QZ]]QVAYY&	4	4 uQw	QVAYY"K	0	0 ur   c                     | j         d         }t          t          j        |          |          r|S t          t          j        |          |          rt
          j        S t          | |          S )a  
    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   r0   	imaginaryr   Zero_refine_reimr$   r   r   s      r   	refine_rerg      sa     )A,C
16#;;$$ 

1;s[)) vk***r   c                     | j         d         }t          t          j        |          |          rt          j        S t          t          j        |          |          rt          j         |z  S t          | |          S )a  
    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   r0   r   rd   rc   ImaginaryUnitre   rf   s      r   	refine_imrj     sl     )A,C
16#;;$$ v
1;s[)) ' 3&&k***r   c                     | j         d         }t          t          j        |          |          rt          j        S t          t          j        |          |          rt          j        S dS )a"  
    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   r[   r   rd   r1   r\   )r$   r   rgs      r   
refine_argrm   *  sV     
1B
1:b>>;'' v
1:b>>;'' t4r   c                 n    |                      d          }|| k    rt          ||          }||k    r|S d S )NT)complex)expandr   )r$   r   expandedrefineds       r   re   re   A  sH    {{T{**H4 ;//h 	N4r   c                    | j         d         }t          t          j        |          |          rt          j        S t          t          j        |                    r\t          t          j        |          |          rt          j        S t          t          j	        |          |          rt          j
        S t          t          j        |                    rt|                                \  }}t          t          j        |          |          rt          j        S t          t          j	        |          |          rt          j         S | S )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   r]   r   rd   r0   r[   rH   r1   rB   rc   as_real_imagri   )r$   r   r   arg_rearg_ims        r   refine_signrw   L  s
   0 )A,C
16#;;$$ v
16#;; !qz#,, 	5Lqz#,, 	!= 
1;s $))++qz&!!;// 	#?"qz&!!;// 	$O##Kr   c                     ddl m} | j        \  }}}t          t	          j        |          |          r&||z
                                  r| S  ||||          S dS )aU  
    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.matexprry   r   r   r   	symmetricrI   )r$   r   ry   matrixr6   js         r   refine_matrixelementr~   u  s{     A@@@@@9LFAq
1;v,, +E++-- 	K}VQ***+ +r   )r+   r
   atan2reimr   r9   ry   N)T)typingr   tDictr   
sympy.corer   r   r   r   r	   r
   r   sympy.core.logicr   sympy.logic.boolalgr   sympy.assumptionsr   r   r   r7   rW   ra   rg   rj   rm   re   rw   r~   r"   r   r   r   <module>r      s\   * * * * * * * * > > > > > > > > > > > > > > > > > > & & & & & & ' ' ' ' ' ' $ $ $ $ $ $ $ $9) 9) 9) 9)x#1 #1 #1La  a  a H* * *Z+ + +.+ + +,  .  & & &R+ + +. 

)	 	r   