
    Цi2                    f   S SK Jr  S SKJr  S SKJr  S SKJr  S SK	r	SSK
J
r
  SSKJrJr  SS	KJr  SS
K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"  S SK#J$r$   " S S5      r%S r&S r' " S S\\5      r(\" S5      r)S S jr*S!S jr+S r,SSK-J.r.  SSK/J0r0  SSK1J2r2J3r3  g)"    )Tuple)defaultdict)reduce)productN   )sympify)Basic_args_sortkey)S)AssocOpAssocOpDispatcher)cacheit)integer_nthroottrailing)	fuzzy_not_fuzzy_group)Expr)global_parameters)KindDispatcher	bottom_up)siftc                   (    \ rS rSrSrSrSrSrSrSr	g)	NC_Marker   F N)
__name__
__module____qualname____firstlineno__is_Orderis_Mul	is_Numberis_Polyis_commutative__static_attributes__r       M/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/core/mul.pyr   r      s    HFIGNr'   r   c                 *    U R                  [        S9  g )Nkey)sortr
   argss    r(   _mulsortr/       s    II-I r'   c                  n   [        U 5      n / n/ n[        R                  nU (       a  U R                  5       nUR                  (       aO  UR                  5       u  pVU R                  U5        U(       a$  UR                  [        R                  U5      5        O'UR                  (       a  X4-  nOUR                  U5        U (       a  M  [        U5        U[        R                  La  UR                  SU5        U(       a$  UR                  [        R                  U5      5        [        R                  U5      $ )a  Return a well-formed unevaluated Mul: Numbers are collected and
put in slot 0, any arguments that are Muls will be flattened, and args
are sorted. Use this when args have changed but you still want to return
an unevaluated Mul.

Examples
========

>>> from sympy.core.mul import _unevaluated_Mul as uMul
>>> from sympy import S, sqrt, Mul
>>> from sympy.abc import x
>>> a = uMul(*[S(3.0), x, S(2)])
>>> a.args[0]
6.00000000000000
>>> a.args[1]
x

Two unevaluated Muls with the same arguments will
always compare as equal during testing:

>>> m = uMul(sqrt(2), sqrt(3))
>>> m == uMul(sqrt(3), sqrt(2))
True
>>> u = Mul(sqrt(3), sqrt(2), evaluate=False)
>>> m == uMul(u)
True
>>> m == Mul(*m.args)
False

r   )listr   Onepopr"   args_cncextendappendMul
_from_argsr#   r/   insert)r.   newargsncargscoacncs          r(   _unevaluated_Mulr@   %   s    > :DGF	
B
HHJ88JJLEAKKNcnnR01[[GBNN1 $ W	q"s~~f-.>>'""r'   c                     ^  \ rS rSr% SrSr\\S4   \S'   Sr	\r
\" SSS9r\S	 5       rS
 rS r\S 5       rS r\S 5       rS r\S 5       r\S 5       r\SS.S j5       rSJS jrSKS jr\S 5       rS r\S 5       r\U 4S j5       r S r!S r"SLS jr#\S 5       r$\SMS j5       r%\S 5       r&\S  5       r'\S! 5       r(\S" 5       r)\S# 5       r*S$ r+S% r,S& r-S' r.S( r/S) r0S* r1S+ r2S, r3S- r4S. r5S/ r6S0 r7S1 r8S2 r9S3 r:S4 r;S5 r<S6 r=S7 r>S8 r?S9 r@S: rAS; rBS< rCS= rDS> rES? rFS@ rGSA rHSNSB jrISOSC jrJSD rKSE rLSF rMSPSG jrNSMSH jrO\SI 5       rPSrQU =rR$ )Qr7   [   a~  
Expression representing multiplication operation for algebraic field.

.. deprecated:: 1.7

   Using arguments that aren't subclasses of :class:`~.Expr` in core
   operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
   deprecated. See :ref:`non-expr-args-deprecated` for details.

Every argument of ``Mul()`` must be ``Expr``. Infix operator ``*``
on most scalar objects in SymPy calls this class.

Another use of ``Mul()`` is to represent the structure of abstract
multiplication so that its arguments can be substituted to return
different class. Refer to examples section for this.

``Mul()`` evaluates the argument unless ``evaluate=False`` is passed.
The evaluation logic includes:

1. Flattening
    ``Mul(x, Mul(y, z))`` -> ``Mul(x, y, z)``

2. Identity removing
    ``Mul(x, 1, y)`` -> ``Mul(x, y)``

3. Exponent collecting by ``.as_base_exp()``
    ``Mul(x, x**2)`` -> ``Pow(x, 3)``

4. Term sorting
    ``Mul(y, x, 2)`` -> ``Mul(2, x, y)``

Since multiplication can be vector space operation, arguments may
have the different :obj:`sympy.core.kind.Kind()`. Kind of the
resulting object is automatically inferred.

Examples
========

>>> from sympy import Mul
>>> from sympy.abc import x, y
>>> Mul(x, 1)
x
>>> Mul(x, x)
x**2

If ``evaluate=False`` is passed, result is not evaluated.

>>> Mul(1, 2, evaluate=False)
1*2
>>> Mul(x, x, evaluate=False)
x*x

``Mul()`` also represents the general structure of multiplication
operation.

>>> from sympy import MatrixSymbol
>>> A = MatrixSymbol('A', 2,2)
>>> expr = Mul(x,y).subs({y:A})
>>> expr
x*A
>>> type(expr)
<class 'sympy.matrices.expressions.matmul.MatMul'>

See Also
========

MatMul

r   .r.   TMul_kind_dispatcher)commutativec                 F    S U R                    5       nU R                  " U6 $ )Nc              3   8   #    U  H  oR                   v   M     g 7fN)kind.0r=   s     r(   	<genexpr>Mul.kind.<locals>.<genexpr>   s     /YVVY   )r.   _kind_dispatcher)self	arg_kindss     r(   rH   Mul.kind   s!    /TYY/	$$i00r'   c                 l    X * :X  a  gU R                   S   nUR                  =(       a    UR                  $ )NFr   )r.   r#   is_extended_negative)rO   r>   s     r(   could_extract_minus_signMul.could_extract_minus_sign   s.    E?IIaL{{5q555r'   c                 T   U R                  5       u  pUS   [        R                  La  U* nU[        R                  LaP  US   R                  (       a6  [        U5      nU[        R                  L a
  US   * US'   OUS==   U-  ss'   OU4U-   nU R                  X R                  5      $ Nr   )	as_coeff_mulr   ComplexInfinityr2   r#   r1   NegativeOner8   r%   )rO   r>   r.   s      r(   __neg__Mul.__neg__   s    ##%7!+++AAEE>Aw  Dz%#AwhDGGqLGtd{t%8%899r'   c           
      :  ^"^6 SSK Jn  SSKJm6  Sn[	        U5      S:X  Ga  Uu  nm"T"R
                  (       a	  T"Usnm"UT"/nU[        R                  Ld   eUR
                  (       a  UR                  (       d  T"R                  5       u  nm"T"R                  (       a  U[        R                  La+  XE-  nU[        R                  L a  T"nO
U " XE-  T"SS9nU// S4nOX[        R                  (       aC  T"R                  (       a2  [        T"R                   Vs/ s H  n[!        XH5      PM     sn6 n	U	// S4nU(       a  U$ / n
/ n/ n[        R                  n/ n/ n[        R"                  n0 nSnU GHH  nUR$                  (       a  UR'                  U5      u  nnUR(                  (       a  UR                  (       a  UR+                  UR                  5        O]UR                   H8  nUR                  (       a  UR-                  U5        M'  UR-                  U5        M:     UR-                  [.        5        M  UR0                  (       a  U[        R2                  L d$  U[        R4                  L a'  UR                  (       a  [        R2                  // S4s  $ UR0                  (       d  [7        X5      (       a.  UU-  nU[        R2                  L a  [        R2                  // S4s  $ GMv  [7        UU5      (       a  UR9                  U5      nGM  U[        R4                  L a0  U(       d  [        R2                  // S4s  $ [        R4                  nGM  U[        R:                  L a  U[        R<                  -  nGM  UR                  (       Ga6  UR?                  5       u  m"nUR@                  (       a  T"R0                  (       a  UR
                  (       a  URB                  (       a  U[E        T"U5      -  nGM  URF                  (       a  UR-                  [E        T"U5      5        GM  T"RF                  (       a  UU-  nT"* m"T"[        R                  La!  URI                  T"/ 5      R-                  U5        GM  T"RJ                  (       d  URL                  (       a  UR-                  T"U45        GM9  UR-                  T"U45        GMO  U[.        La  UR-                  U5        U(       d  GMs  URO                  S5      nU(       d  UR-                  U5        M5  URO                  5       nUR?                  5       u  nnUR?                  5       u  nnUU-   nUU:X  aM  UR                  (       d<  UU-  nUR                  (       a  UR-                  U5        M  URQ                  SU5        OUR+                  UU/5        U(       a  M  GMK     S nU" U5      nU" U5      n[S        S5       GH  n/ nSn U GHJ  u  m"nUR                  (       a  T"R                  (       d  T"R(                  (       a_  [U        U"4S	 j[        R4                  [        RV                  [        RX                  4 5       5      (       a  [        R2                  // S4s  s  $ M  U[        R                  L a  T"R0                  (       a  UT"-  nM  T"n!U[        R                  LaK  [E        T"U5      n!U!R@                  (       a.  T"R@                  (       d  T"nU!R?                  5       u  m"nT"U:w  a  S
n U
R-                  W!5        UR-                  T"U45        GMM     U (       a;  [	        U V"Vs1 s H  u  n"nU"iM
     snn"5      [	        U5      :w  a  / n
U" U5      nGM    O   0 n#U H'  u  m"nU#RI                  U/ 5      R-                  T"5        M)     U#R[                  5        H  u  nm"U " T"6 U#U'   M     U
R+                  U#R[                  5        VV"s/ s H  u  nn"U(       d  M  [E        U"U5      PM     sn"n5        0 n$UR[                  5        H-  u  m"nU$RI                  [        U6 / 5      R-                  T"5        M/     A/ n%U$R[                  5        H  u  nm"U " T"6 m"UR\                  S:X  a  U[E        T"U5      -  nM,  UR^                  UR\                  :  aH  [a        UR^                  UR\                  5      u  n&n'U[E        T"U&5      -  n[c        U'UR\                  5      nU%R-                  T"U45        M     A$[e        [f        5      n(SnU[	        U%5      :  Ga  U%U   u  nn)US:X  a  US-  nM%  / n*[S        US-   [	        U%5      5       H  n+U%U+   u  n,n-URi                  U,5      n.U.[        R                  Ld  M1  U)U--   nUR\                  S:X  a  U[E        U.U5      -  nOuUR^                  UR\                  :  aH  [a        UR^                  UR\                  5      u  n&n'U[E        U.U&5      -  n[c        U'UR\                  5      nU*R-                  U.U45        U,U.-  U-4U%U+'   UU.-  nU[        R                  L d  M    O   U[        R                  La  [E        UU)5      n/U/R0                  (       a  UU/-  nOj[j        Rm                  U/5       HQ  n/U/R0                  (       a  UU/-  nM  U/R@                  (       d   eU/R                  u  nn)U(U)   R-                  U5        MS     U%R+                  U*5        US-  nU[	        U%5      :  a  GM  U(R[                  5        H  u  nm"U " T"6 U(U'   M     U(       a  URo                  5       u  n!n[a        U!U5      u  n0n!U0S-  (       a  U* nUS:X  a   U
R-                  [        R:                  5        OvU!(       ao  [c        U!U5      nU(R[                  5        H'  u  nm"UU:X  d  M  T"RJ                  (       d  M!  T"* U(U'     O*   U
R-                  [E        [        Rp                  USS95        U
R+                  U(R[                  5        VV"s/ s H  u  nn"[E        U"U5      PM     sn"n5        U[        RV                  [        RX                  4;   a   S n1U1" U
S5      u  n
n2U1" UU25      u  nn2UU2-  nU[        R4                  L aw  U
 V3s/ s H.  n3[s        U3R                  5      (       a  U3Rt                  b  M,  U3PM0     n
n3U V3s/ s H.  n3[s        U3R                  5      (       a  U3Rt                  b  M,  U3PM0     nn3ObUR                  (       aQ  [U        U64S jU 5       5      (       a  U/UU4$ [U        S U
 5       5      (       a  [        R2                  // U4$ U// U4$ / n4U
 H,  nUR0                  (       a  UU-  nM  U4R-                  U5        M.     U4n
[w        U
5        U[        R                  La  U
RQ                  SU5        [        R                  (       a  U(       dz  [	        U
5      S:X  ak  U
S   R0                  (       aW  U
S   Rx                  (       aC  U
S   R                  (       a/  U
S   n[        U
S   R                   V5s/ s H  n5UU5-  PM
     sn56 /n
XU4$ s  snf s  snn"f s  sn"nf s  sn"nf s  sn3f s  sn3f s  sn5f )a6  Return commutative, noncommutative and order arguments by
combining related terms.

Notes
=====
    * In an expression like ``a*b*c``, Python process this through SymPy
      as ``Mul(Mul(a, b), c)``. This can have undesirable consequences.

      -  Sometimes terms are not combined as one would like:
         {c.f. https://github.com/sympy/sympy/issues/4596}

        >>> from sympy import Mul, sqrt
        >>> from sympy.abc import x, y, z
        >>> 2*(x + 1) # this is the 2-arg Mul behavior
        2*x + 2
        >>> y*(x + 1)*2
        2*y*(x + 1)
        >>> 2*(x + 1)*y # 2-arg result will be obtained first
        y*(2*x + 2)
        >>> Mul(2, x + 1, y) # all 3 args simultaneously processed
        2*y*(x + 1)
        >>> 2*((x + 1)*y) # parentheses can control this behavior
        2*y*(x + 1)

        Powers with compound bases may not find a single base to
        combine with unless all arguments are processed at once.
        Post-processing may be necessary in such cases.
        {c.f. https://github.com/sympy/sympy/issues/5728}

        >>> a = sqrt(x*sqrt(y))
        >>> a**3
        (x*sqrt(y))**(3/2)
        >>> Mul(a,a,a)
        (x*sqrt(y))**(3/2)
        >>> a*a*a
        x*sqrt(y)*sqrt(x*sqrt(y))
        >>> _.subs(a.base, z).subs(z, a.base)
        (x*sqrt(y))**(3/2)

      -  If more than two terms are being multiplied then all the
         previous terms will be re-processed for each new argument.
         So if each of ``a``, ``b`` and ``c`` were :class:`Mul`
         expression, then ``a*b*c`` (or building up the product
         with ``*=``) will process all the arguments of ``a`` and
         ``b`` twice: once when ``a*b`` is computed and again when
         ``c`` is multiplied.

         Using ``Mul(a, b, c)`` will process all arguments once.

    * The results of Mul are cached according to arguments, so flatten
      will only be called once for ``Mul(a, b, c)``. If you can
      structure a calculation so the arguments are most likely to be
      repeats then this can save time in computing the answer. For
      example, say you had a Mul, M, that you wished to divide by ``d[i]``
      and multiply by ``n[i]`` and you suspect there are many repeats
      in ``n``. It would be better to compute ``M*n[i]/d[i]`` rather
      than ``M/d[i]*n[i]`` since every time n[i] is a repeat, the
      product, ``M*n[i]`` will be returned without flattening -- the
      cached value will be returned. If you divide by the ``d[i]``
      first (and those are more unique than the ``n[i]``) then that will
      create a new Mul, ``M/d[i]`` the args of which will be traversed
      again when it is multiplied by ``n[i]``.

      {c.f. https://github.com/sympy/sympy/issues/5706}

      This consideration is moot if the cache is turned off.

    NB
    --
      The validity of the above notes depends on the implementation
      details of Mul and flatten which may change at any time. Therefore,
      you should only consider them when your code is highly performance
      sensitive.

      Removal of 1 from the sequence is already handled by AssocOp.__new__.
r   )AccumBounds)
MatrixExprN   Fevaluatec           
         0 nU  HL  u  p#UR                  5       nUR                  U0 5      R                  US   / 5      R                  US   5        MN     UR                  5        H(  u  p%UR                  5        H  u  pg[	        U6 XV'   M     M*     / nUR                  5        H=  u  p#UR                  UR                  5        V	V
s/ s H  u  pX*U	-  4PM     sn
n	5        M?     U$ s  sn
n	f Nr   r   )as_coeff_Mul
setdefaultr6   itemsAddr5   )c_powerscommon_bber<   ddilinew_c_powerstr>   s              r(   _gatherMul.flatten.<locals>._gather  s    H ^^%##Ar*55qE2%vbe} ! !(ggiFBHAE ( ) L (##!'')$D)$!a1X)$DE ) %Es   C&c              3   B   >#    U  H  nUTR                   ;   v   M     g 7frG   r-   )rJ   inftyrk   s     r(   rK   Mul.flatten.<locals>.<genexpr>  s$      6;&:E 7<qvvo&:s   Tr   c                     / nU  H?  nUR                   (       a  M  UR                  (       a  US-  nM.  UR                  U5        MA     X!4$ N)is_extended_positiverS   r6   )c_part
coeff_sign
new_c_partrq   s       r(   _handle_for_oo#Mul.flatten.<locals>._handle_for_oo  sL    
A-- --"b(
 %%a(   "--r'   c              3   <   >#    U  H  n[        UT5      v   M     g 7frG   )
isinstance)rJ   r>   r_   s     r(   rK   rv     s     >g:a,,gs   c              3   >   #    U  H  oR                   S :H  v   M     g7fFN	is_finite)rJ   r>   s     r(   rK   rv     s     8A;;%'   )=!sympy.calculus.accumulationboundsr^   sympy.matrices.expressionsr_   lenis_Rationalr   r2   is_zerore   is_Addr   
distributer%   rh   r.   _keep_coeffZeror!   as_expr_variablesr"   r5   r6   r   r#   NaNrY   r   __mul__ImaginaryUnitHalfas_base_expis_Pow
is_IntegerPowis_negativerf   is_positive
is_integerr3   r9   rangeanyInfinityNegativeInfinityrg   qpdivmodRationalr   r1   gcdr7   	make_argsas_numer_denomrZ   r   is_extended_realr/   r   )7clsseqr^   rvr=   rararbbinewbr{   nc_partnc_seqcoeffri   num_expneg1epnum_ratorder_symbolsor   rl   o1b1e1b2e2new_expo12rr   irp   changedr   rk   inv_exp_dictcomb_enum_rate_ieppneweigrowjbjejgobjnr~   r|   r>   _newfr_   s7                                     `                   @r(   flattenMul.flatten   s   ^ 	B9s8q=DAq}}!1!fAEE>!>}}QYY~~'188~S;"#C"%ac1u"=C!UB_*55!:J:J"!&&$I&B[%7&$IJ"VR-	      Azz#$#6#6}#E = xx##JJqvv& VV++JJqM"MM!,	 $ JJy) :!*;*;!;		EE7B,,__
5(F(FQJE~ !wD00A{++		%(a'''EE7B,,))aoo%!!! }}1 88{{
 == || %Q 2 (!" #

3q!9 5 (!" %
%&B ~ ( 3 3Ar : A A! D$]]all#NNAq62$A'
 I%MM!$ f

1A"q)  !B^^-FB]]_FB 2gG
 Rx Gm --JJsO$"MM!S1  Aw/7 fu H	  8$ '"0 qALG 199AHH# 6;&'&7&7&'&8&8&:6; 3; 3; !"wD00:{{
 AAEE>Aq	A xx }}17&*Ga ##QF+1 !6 3". 0".$!QA, 0 1474EF "<0I P DAq##Ar*11!4  &&(DAq!1gLO )\-?-?-AG-ATQQys1ay-AGH NN$DAqc1gr*11!4 % LLNDAqQAssaxQ"ssQSSy acc*RQ$R%NNAq6" #  4 #g,QZFBQwQD1q5#g,/ BFF2JAEE> RAssaxQ*339&,QSS!##&6GC!SC[0E (QSS 1AQF+"$Q$GAJABQUU{) 0* "bk==SLE  #}}S1==!SLE#&::-:%(XXFB HOOB/  2 NN4 FAU #g,Z JJLDAq1gDG ! ((*DAq!Q<DAq1uAvaoo. !A JJLDAqEzammm#$"Q ) MM#ammUU"KL 	TZZ\:\TQs1ay\:; QZZ!3!344	. "0!:FJ"0*"EGZZE A%%% "( QA	!))0D0D010B0B F Q") S'Q)AII2F2F232D2D 'G SG ]] >g>>>w668888wM117B-- A{{
A	 
  	 MM!U# ((S[A=Mq	##q	(;(;q	@P@P1IEVAY^^<^E!G^<=>F--M %Jd 0  HJ ;2QSD =s<   y7?y<#z
5z
&z
"+zz+zzzc                 .   U R                  SS9u  p#UR                  (       a@  [        U Vs/ s H  n[        XASS9PM     sn6 [        [        R	                  U5      USS9-  $ UR
                  (       a  UR                  S:X  a  U R                  (       a  U R                  5       S   nUR
                  (       a  [        US-  5      R                  5       u  pg[        US5      u  phU(       ah  [        US5      u  pxU(       aS  SSKJn	  [        U5      U-  n
[        XR                   -  SU	" U5      ["        R$                  -  -   UR                   -  5      $ [        XSS9nUR
                  (       d  UR&                  (       a  UR)                  5       $ U$ s  snf )NF)split_1ra   r`   r   r   sign)r4   r   r7   r   r8   r   r   is_imaginaryas_real_imagabsr   r   $sympy.functions.elementary.complexesr   r   r@   r   r   r   is_Float_eval_expand_power_base)rO   rl   cargsr?   rk   r=   r   rm   rq   r   r   r   s               r(   _eval_powerMul._eval_power  s<    MM%M0	<<EBEqQE2EBCCNN2&E:; ;==QSSAX  %%'*==qs8224DA*1a0DA.q!4Q '
1A#3AssFQaAX=X[\[^[^<^#__%(==AJJ,,..) Cs   Fc                      SSU R                   4$ )N   r   )r   r   s    r(   	class_keyMul.class_key  s    !S\\!!r'   c                 D   U R                  5       u  p#U[        R                  L aC  UR                  (       a  [        R
                  " X15      * nO0UR                  U5      nUb  UnU* nO[        R
                  " X5      nUR                  (       a  UR                  5       $ U$ rG   )re   r   rZ   r"   r   _eval_evalf	is_numberexpand)rO   precr>   mr   mnews         r(   r   Mul._eval_evalf  s      "xx))!22}}T*#AR$$T0B<<99;	r'   c                     SSK Jn  U R                  5       u  p#U[        R                  La  [        S5      eU" S5      R                  U" U5      R                  4$ )z+
Convert self to an mpmath mpc if possible
r   )Floatz7Cannot convert Mul to mpc. Must be of the form Number*Ir   )numbersr   re   r   r   AttributeError_mpf_)rO   r   im_part	imag_units       r(   _mpc_	Mul._mpc_  sO    
 	#!..0AOO+ !!Z[[ag 4 455r'   c                     U R                   n[        U5      S:X  a  [        R                  U 4$ [        U5      S:X  a  U$ US   U R                  " USS 6 4$ )a  Return head and tail of self.

This is the most efficient way to get the head and tail of an
expression.

- if you want only the head, use self.args[0];
- if you want to process the arguments of the tail then use
  self.as_coef_mul() which gives the head and a tuple containing
  the arguments of the tail when treated as a Mul.
- if you want the coefficient when self is treated as an Add
  then use self.as_coeff_add()[0]

Examples
========

>>> from sympy.abc import x, y
>>> (3*x*y).as_two_terms()
(3, x*y)
r   r`   r   N)r.   r   r   r2   _new_rawargs)rO   r.   s     r(   as_two_termsMul.as_two_terms  sX    * yyt9>55$;Y!^K 7D--tABx888r'   )rationalc                  ^ T(       a5  [        U R                  U4S jSS9u  pEU R                  " U6 [        U5      4$ U R                  nUS   R                  (       aV  U(       a  US   R
                  (       a
  US   USS  4$ US   R                  (       a  [        R                  US   * 4USS  -   4$ [        R                  U4$ )Nc                 "   > U R                   " T6 $ rG   )has)xdepss    r(   <lambda>"Mul.as_coeff_mul.<locals>.<lambda>0  s    quud|r'   T)binaryr   r   )
r   r.   r   tupler#   r   rS   r   rZ   r2   )rO   r   r   kwargsl1l2r.   s     `    r(   rX   Mul.as_coeff_mul-  s    $))%;DIFB$$b)5944yy7tAw22AwQR((a--}}QxkDH&<<<uud{r'   c                 f   U R                   S   U R                   SS p2UR                  (       ar  U(       a  UR                  (       a%  [        U5      S:X  a  X#S   4$ X R                  " U6 4$ UR
                  (       a$  [        R                  U R                  " U* 4U-   6 4$ [        R                  U 4$ )z3
Efficiently extract the coefficient of a product.
r   r   N)	r.   r#   r   r   r   rS   r   rZ   r2   )rO   r   r   r.   s       r(   re   Mul.as_coeff_Mul:  s     iilDIIabMt??u00t9> q'>) "3"3T":::++}}d&7&7E6)d:J&LLLuud{r'   c                     SSK JnJnJn  / n/ n/ n[        R
                  n	U R                   GH  n
U
R                  5       u  pUR                  (       a  UR                  U5        M:  UR                  (       a$  UR                  U[        R                  -  5        Mo  U
R                  (       a{  U(       a  U
R                  5       OS n[        U5       H)  u  pX:X  d  M  UR                  U" U5      S-  5        Xl	   M     U
R                  (       a  X-  n	M  UR                  U
5        M  UR                  U
5        GM     U R                  " U6 nUR!                  S5      U:X  a  g [#        U5      S-  (       a  U" UR%                  S5      5      nO[        R&                  nU R                  " Xx-   6 nUU" U5      -  UU" U5      -  pU	S:X  a_  US:X  a8  UR                  (       a  U[        R&                  4$ [        R&                  UU-  4$ U[        R&                  L a  X4$ U* U-  UU-  4$ SSKJn  U" U	SS9R                  5       u  nnU[        R&                  L a  UU-  UU-  -
  UU-  UU-  -   4$ U* U-  UU-  pUU-  UU-  -
  UU-  UU-  -   4$ )	Nr   )Absimrer`   ignorer   )
expand_mulF)deep)r   r  r  r  r   r2   r.   r   r   r6   r   r%   	conjugate	enumerater   funcgetr   r3   r   functionr  )rO   r  hintsr  r  r  othercoeffrcoeffiaddtermsr=   r   r   aconjr   r   imcorecor  addreaddims                        r(   r   Mul.as_real_imagJ  s-   DD55A>>#DAyya a/0!!).D%e,DAzc!fai0!H	 - xx QQ) * IIu99X!#v;?fjjm$D 66Dyy6?,RU
DAJ1q=Av<< !&&>)FFDI..qvv~vE!GT!V$$(!(7DDFu166>eGag%qw5'89957DFqeGag%qw5'899r'   c           	      D   [        U 5      nUS:X  a  U S   R                  $ / n[        R                  U SUS-   5      n[        R                  XS-  S 5      nU VVs/ s H  oT  H  n[        XV5      PM     M     nnn[	        U6 n[        R
                  " U5      $ s  snnf )zS
Helper function for _eval_expand_mul.

sums must be a list of instances of Basic.
r   r   Nr`   )r   r.   r7   _expandsumsrh   r   )sumsLtermsleftrightr=   rk   addeds           r(   r"  Mul._expandsums  s     I67<<tEQT{+TU,$(8Dq%QQ%D8U}}U## 9s   Bc                    SSK Jn  U nU" X1R                  SS5      5      u  pEUR                  (       a9  XE4 Vs/ s H(  nUR                  (       a  UR                  " S0 UD6OUPM*     snu  pEXE-  nUR                  (       d  U$ / / SpnUR
                   Hg  n
U
R                  (       a  UR                  U
5        Sn	M)  U
R                  (       a  UR                  U
5        MM  UR                  [        U
5      5        Mi     U	(       d  U$ U R                  " U6 nU(       a  UR                  SS5      nU R                  R                  U5      n/ nU Hn  nU R                  X~5      nUR                  (       a8  [        S UR
                   5       5      (       a  U(       a  UR	                  5       nUR                  U5        Mp     [        U6 $ U$ s  snf )	Nr   fractionexactFTr  c              3   8   #    U  H  oR                   v   M     g 7frG   )r   rI   s     r(   rK   'Mul._eval_expand_mul.<locals>.<genexpr>  s     'A&Q&rM   r   )sympy.simplify.radsimpr,  r  r"   _eval_expand_mulr.   r   r6   r%   r	   r  r"  r   rh   )rO   r  r,  exprr   rm   r   plainr#  rewritefactorr  r%  r.   termrq   s                   r(   r1  Mul._eval_expand_mul  sv   3 ii7888!A 4588A&&//B!DAs{{K!2uWiiF}}F#((LL(KKf.   KIIu%Eyy/		--d3!D		%.AxxC'A!&&'A$A$Ad..0KKN	 "
 Dz!A!s   /Gc           
      >   [        U R                  5      n/ n[        [        U5      5       HY  nX$   R	                  U5      nU(       d  M  UR                  [        S US U U/-   X$S-   S  -   [        R                  5      5        M[     [        R                  " U5      $ )Nc                 
    X-  $ rG   r   )r   ys     r(   r   &Mul._eval_derivative.<locals>.<lambda>  s    r'   r   )r1   r.   r   r   diffr6   r   r   r2   rh   fromiter)rO   sr.   r%  r   rm   s         r(   _eval_derivativeMul._eval_derivative  s    DIIs4y!AQAq V$4tBQx1#~QRUV7TWXW\W\]^ " ||E""r'   c                 Z  > SSK Jn  SSKJnJnJn  [        XU45      (       d  [        TU ]!  X5      $ SSK	J
n  U R                  n[        U5      n	[        U[        U45      (       ak  / n
SSKJn  U" X5       HO  u  p[!        [#        X5       VVs/ s H  u  pUR%                  X45      PM     snn6 nU
R'                  UU-  5        MQ     [)        U
6 $ SSKJn  SSKJn  SS	KJn  U" S
U	-  US9nU[7        U5      -
  nU" U5      nU[9        [;        UU5      5      -  U" U5      -  [!        [=        U	S-
  5       Vs/ s H  nUU   R%                  XU   45      PM     sn6 -  US   R%                  UU" SU5      45      -  U Vs/ s H  oSU4PM	     snnnU" U/UQ76 $ s  snnf s  snf s  snf )Nr   )AppliedUndef)SymbolsymbolsDummy)Integerr   )!multinomial_coefficients_iterator)Sum)	factorial)Maxzk1:%ir   ry   )r  rB  symbolrC  rD  rE  r   super_eval_derivative_n_timesr   rF  r.   r   intsympy.ntheory.multinomialrG  r7   zipr<  r6   rh   sympy.concrete.summationsrH  (sympy.functions.combinatorial.factorialsrI  (sympy.functions.elementary.miscellaneousrJ  sumprodmapr   )rO   r>  r   rB  rC  rD  rE  rF  r.   r   r%  rG  kvalsr>   kargr   rH  rI  rJ  klastnfactrq   rl   l	__class__s                            r(   rM  Mul._eval_derivative_n_times  s   *22!F344 73A99$yyIa#w((ES=aCU9IJ9Ivq#((A6*9IJKQU# D ;1F@!/CJ!$s9e,--i.>>uQqSzBz!$q',,8}-zBCDHMM1c!Um,-. !&&1AY&	 
 1zqz K C&s   F9"F#
F(c                     SSK Jn  U R                  S   n[        U R                  SS  6 nUR	                  XU-   5      U" XQU5      -  U" XAU5      U-  -   $ )Nr   )difference_deltar   )sympy.series.limitseqr`  r.   r7   subs)rO   r   stepddarg0rests         r(   _eval_difference_deltaMul._eval_difference_delta  s]    @yy|DIIabM"		!X&DT)::R=N>  	r'   c                     U R                  5       u  p4[        R                  U5      n[        U5      S:X  a/  U R                  R                  X5      nUS   R                  XR5      $ g rd   )re   r7   r   r   r]  _combine_inversematches)rO   r2  	repl_dictr   r%  newexprs         r(   _matches_simpleMul._matches_simple  sW    ((*e$u:?nn55dBG8##G77r'   c                 8   [        U5      nU R                  (       a#  UR                  (       a  U R                  XU5      $ U R                  UR                  La  g U R                  5       u  pEUR                  5       u  pgXF4 Vs/ s H  o=(       d    S/PM     snu  pF[	        U6 n	[	        U6 n
U	R                  XU5      nU(       d  XF:w  a  g [        R                  U5      n[        R                  U5      n[        R                  XWU5      nU=(       d    S $ s  snf Nr   )r   r%   _matches_commutativer4   r7   rk  _matches_expand_pows_matches_noncomm)rO   r2  rl  oldc1nc1c2nc2r>   comm_mul_selfcomm_mul_exprs              r(   rk  Mul.matches  s    t}4#6#6,,TcBB  (;(;; --/--/%'H-Hq(s(H- RR!))-CH	 RX &&s+&&s+((9=	 D ) .s   Dc                     / nU  H`  nUR                   (       a;  UR                  S:  a+  UR                  UR                  /UR                  -  5        MO  UR	                  U5        Mb     U$ rW   )r   expr5   baser6   )arg_listnew_argsrY  s      r(   rs  Mul._matches_expand_pows  sP    Czzcggk
SWW 45$	 
 r'   c                    Uc  0 nOUR                  5       n/ nSnUu  pV0 nU[        U5      :  a  U[        U 5      :  a  X   nUR                  (       a  [        R	                  Xt5        [        R                  XtX5      n	U	(       a+  U	u  pUR                  U
5        U(       a  U H	  nX   X,'   M     U(       d  gUR                  5       nUu  pVU[        U5      :  a  U[        U 5      :  a  M  U$ )zNon-commutative multiplication matcher.

`nodes` is a list of symbols within the matcher multiplication
expression, while `targets` is a list of arguments in the
multiplication expression being matched against.
N)r   r   )copyr   is_Wildr7   _matches_add_wildcard_matches_new_statesr5   r3   )nodestargetsrl  agendastatenode_ind
target_indwildcard_dictnodestates_matches
new_statesnew_matchesmatchs                r(   rt  Mul._matches_noncomm%  s     I!(I $3w<'Hs5z,A?D||))-? 44]5:EN*8'
j)!,+6+=	( "-

',$% 3w<'Hs5z,A( r'   c                 8    Uu  p#X ;   a  X   u  pEXC4X'   g X34X'   g rG   r   )
dictionaryr  r  r  beginends         r(   r  Mul._matches_add_wildcardP  s0    $!#-JE$)#6J $.#;J r'   c                    Uu  pEX$   nX5   nU[        U5      S-
  :  a  U[        U5      S-
  :  a  g UR                  (       a  [        R                  XX#5      nU(       a  [        R	                  U X$5      n	U	 H<  n
X
   u  pX   u  pX;US-    nX=US-    n[        UU5       H  u  nnUU:w  d  M      g    M>     XES-   4/nU[        U5      S-
  :  a  UR                  US-   US-   45        UU4$ g U[        U5      S-
  :  a  U[        U5      S-
  :  a  g UR                  U5      nU(       a  US-   US-   4/U4$ Xg:X  a  US-   US-   4/S 4$ g rq  )r   r  r7   _matches_match_wilds_matches_get_other_nodesrP  r6   rk  )r  r  r  r  r  r  r  targetmatch_attemptother_node_indsindother_begin	other_end
curr_begincurr_endother_targetscurrent_targetscurrr  	new_states                       r(   r  Mul._matches_new_statesY  s   $$ W))hUa.G<<44Z5:EM #&">">z?D#P*C-7_*K+5+?(J$+	A$FM&-A&FO'*?M'Je5=#' (K + 'Q78	c%j1n,$$hlJN%CD -/// 8 3u:>)j3w<!;K.K LL0M!AzA~67FF!AzA~67==r'   c                 ~    X!   nX   u  pVX5US-    n[        U5      S:  a  [        U6 OUS   nUR                  U5      $ )z@Determine matches of a wildcard with sub-expression in `target`.r   r   )r   r7   rk  )	r  wildcard_indr  r  wildcardr  r  r%  mults	            r(   r  Mul._matches_match_wilds  sN     &-
cAg&!%j1nsE{%(%%r'   c                 N    X   nU  Vs/ s H  oAU   U:X  d  M  UPM     sn$ s  snf )z8Find other wildcards that may have already been matched.r   )r  r  r  ind_noder  s        r(   r  Mul._matches_get_other_nodes  s,     ?)Dz3Z8-CzDDDs   ""c                    SSK Jn  SSKJn  X:X  a  [        R
                  $ S nU" X5      (       d  U" X5      (       a  [        R
                  $ [        S X4 5       5      (       GaZ  U" S5      n[        R                  U0nU[        R                  0nU R                  U5      R                  5       nUR                  U5      R                  5       n	[        U	5      n
[        U	R                  5       5       HA  nX;   d  M
  X==   U	R                  U5      -  ss'   X   (       a  M0  UR                  U5        MC     [        U	5      U
:w  ax  [        UR                  5        VVs/ s H	  u  pX-  PM     snn6 R                  U5      n [        U	R                  5        VVs/ s H	  u  pX-  PM     snn6 R                  U5      nX-  nU" U5      nUR                   (       a  U$ U$ s  snnf s  snnf )z
Returns lhs/rhs, but treats arguments like symbols, so things
like oo/oo return 1 (instead of a nan) and ``I`` behaves like
a symbol instead of sqrt(-1).
r   )signsimpr   )rE  c                     U R                   (       aB  UR                  (       a1  U R                  S5      UR                  5       R                  S5      :H  $ g)Nr   F)r   is_comparable__add__evalf)r\  r   s     r(   check#Mul._combine_inverse.<locals>.check  s8    zzaoo yy|qwwy'8'8';;;r'   c              3   ^   #    U  H#  oR                   =(       d    UR                  v   M%     g 7frG   )r   r"   rJ   r   s     r(   rK   'Mul._combine_inverse.<locals>.<genexpr>  s     8Zxx#188#Z   +-I)sympy.simplify.simplifyr  rK  rE  r   r2   r   r   xreplaceas_powers_dictr   r  keysr3   r7   rg   r#   )lhsrhsr  rE  r  rm   _ii_r=   rk   blenr   rX  vr   srvs                   r(   rj  Mul._combine_inverse  s{    	5!:55L	 ??eCoo55L8cZ888 c
A//1%BQ__%BR //1AR //1Aq6DAFFHo7EQUU2Y&E55b		 &
 1v~QWWY7YTQADY78AA"EQWWY7YTQADY78AA"EWrlmms++	 87s   "G#
G)
c                     [        [        5      nU R                   H6  nUR                  5       R	                  5        H  u  p4X==   U-  ss'   M     M8     U$ rG   )r   rN  r.   r  rg   )rO   rm   r6  rk   rl   s        r(   r  Mul.as_powers_dict  sJ    IID++-335	 6  r'   c           	          [        [        U R                   Vs/ s H  oR                  5       PM     sn6 5      u  p#U R                  " U6 U R                  " U6 4$ s  snf rG   )r1   rP  r.   r   r  )rO   r   numersdenomss       r(   r   Mul.as_numer_denom  sR     c		#J	1$4$4$6	#JKLyy&!499f#555 $Ks   Ac                    S n/ nSnU R                    Ha  nUR                  5       u  pVUR                  (       d  US-  nUc  UnOXa:w  d  US:  a  U [        R                  4s  $ UR                  U5        Mc     U R                  " U6 U4$ )Nr   r   )r.   r   r%   r   r2   r6   r  )rO   r   basesr?   r   rk   rl   s          r(   r   Mul.as_base_exp  s    A==?DA##azBFQUU{"LLO  yy% "$$r'   c                 B   ^ [        U4S jU R                   5       5      $ )Nc              3   D   >#    U  H  oR                  T5      v   M     g 7frG   )_eval_is_polynomialrJ   r6  symss     r(   rK   *Mul._eval_is_polynomial.<locals>.<genexpr>  s     Hid++D11i    allr.   rO   r  s    `r(   r  Mul._eval_is_polynomial  s    HdiiHHHr'   c                 B   ^ [        U4S jU R                   5       5      $ )Nc              3   D   >#    U  H  oR                  T5      v   M     g 7frG   )_eval_is_rational_functionr  s     r(   rK   1Mul._eval_is_rational_function.<locals>.<genexpr>  s     OYT22488Yr  r  r  s    `r(   r  Mul._eval_is_rational_function  s    OTYYOOOr'   c                 D   ^^ [        UU4S jU R                   5       SS9$ )Nc              3   F   >#    U  H  oR                  TT5      v   M     g 7frG   )is_meromorphic)rJ   rY  r=   r   s     r(   rK   +Mul._eval_is_meromorphic.<locals>.<genexpr>  s     K#//155s   !T
quick_exitr   r.   )rO   r   r=   s    ``r(   _eval_is_meromorphicMul._eval_is_meromorphic  s    KK'+- 	-r'   c                 B   ^ [        U4S jU R                   5       5      $ )Nc              3   D   >#    U  H  oR                  T5      v   M     g 7frG   )_eval_is_algebraic_exprr  s     r(   rK   .Mul._eval_is_algebraic_expr.<locals>.<genexpr>  s     L)$//55)r  r  r  s    `r(   r  Mul._eval_is_algebraic_expr  s    L$))LLLr'   c                 :    [        S U R                   5       5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frG   )r%   rI   s     r(   rK   Mul.<lambda>.<locals>.<genexpr>  s      5-"+Q)rM   r  rO   s    r(   r   Mul.<lambda>  s     5-"&))5- )-r'   c                     [        S U R                   5       5      nUSL aD  [        S U R                   5       5      (       a#  [        S U R                   5       5      (       a  g gU$ )Nc              3   8   #    U  H  oR                   v   M     g 7frG   )
is_complexrI   s     r(   rK   'Mul._eval_is_complex.<locals>.<genexpr>  s     <)QLL)rM   Fc              3   8   #    U  H  oR                   v   M     g 7frG   )is_infiniterI   s     r(   rK   r    s     4)Q==)rM   c              3   <   #    U  H  oR                   S Lv   M     g7fr   r   rI   s     r(   rK   r    s     Ay!yy-y   )r   r.   r   )rO   comps     r(   _eval_is_complexMul._eval_is_complex  sR    <$))<<5=4$))444AtyyAAAr'   c                    S=pU R                    Hu  nUR                  (       a  USLa    gSnM  UR                  (       a  USLa    gSnM;  USL a  UR                  c	  USLa    gS nUSL d  M]  UR                  b  Ml  USLa    gS nMw     X4$ )NF)NNT)r.   r   r  )rO   	seen_zeroseen_infiniter=   s       r(   _eval_is_zero_infinite_helper!Mul._eval_is_zero_infinite_helper  s    X %*)	Ayy -% 	E)% $%!))*;$E1) $I E)amm.C -)$(M# & ''r'   c                 J    U R                  5       u  pUSL a  gUSL a  USL a  gg NFTr  rO   r  r  s      r(   _eval_is_zeroMul._eval_is_zeroA  s5     $(#E#E#G 	$=E#9r'   c                 J    U R                  5       u  pUSL a  USL a  gUSL a  gg )NTFr
  r  s      r(   _eval_is_infiniteMul._eval_is_infiniteM  s5     $(#E#E#G 	D Y%%7e#r'   c                     [        S U R                   5       SS9nU(       a  U$ USL a#  [        S U R                   5       5      (       a  gg g )Nc              3   8   #    U  H  oR                   v   M     g 7frG   )is_rationalrI   s     r(   rK   (Mul._eval_is_rational.<locals>.<genexpr>]  s     ;A--rM   Tr  Fc              3   <   #    U  H  oR                   S L v   M     g7fr   r  rI   s     r(   rK   r  b       9y!99%yr  r   r.   r  rO   r   s     r(   _eval_is_rationalMul._eval_is_rational\  sI    ;;MH%Z9tyy999 : r'   c                     [        S U R                   5       SS9nU(       a  U$ USL a#  [        S U R                   5       5      (       a  gg g )Nc              3   8   #    U  H  oR                   v   M     g 7frG   )is_algebraicrI   s     r(   rK   )Mul._eval_is_algebraic.<locals>.<genexpr>f  s     <)Q..)rM   Tr  Fc              3   <   #    U  H  oR                   S L v   M     g7fr   r  rI   s     r(   rK   r  k  r  r  r  r  s     r(   _eval_is_algebraicMul._eval_is_algebraice  sI    <$))<NH%Z9tyy999 : r'   c                 `  ^ U R                  5       nUSL a  g/ n/ nSnU R                   GH  nSnUR                  (       a1  [        U5      [        R
                  La  UR                  U5        MF  MH  UR                  (       ag  UR                  5       u  px[        U5      [        R
                  La  UR                  U5        U[        R
                  La  UR                  U5        M  M  UR                  (       a  UR                  5       u  pU	R                  (       a  U
R                  (       d  S=pdU
R                  (       aA  UR                  U[        R                  L a  SO[        U[        R                  5      5        GMZ  U(       d(  U
R                  (       a   eU
R                   (       a   e  g   g   g    U(       d  U(       d  gS nS nS nSSKJm  U(       d"  U(       a  ['        U4S	 jU 5       5      (       a  gU(       a  g U" U5      (       a  U" U5      (       a  gU" U5      (       a  US/:X  a  gU" U5      (       a+  U" U5      (       a  [)        US
S06S-
  R                  (       a  g[+        U5      S:X  a  US   nUR,                  (       at  UR.                  (       ac  [1        U Vs/ s H)  nUR.                  (       d  M  UR                  5       S   PM+     sn6 [3        UR4                  5      -
  R6                  (       a  g[+        U5      S:X  a  US   nUR,                  (       av  UR.                  (       ad  [1        U Vs/ s H)  nUR.                  (       d  M  UR                  5       S   PM+     sn6 [3        UR4                  5      -
  R                  (       a  gg g g g s  snf s  snf )NFTr`   c                 &    [        S U  5       5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frG   )is_oddr  s     r(   rK   9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>  s     3AxxrM   r  r   s    r(   r   &Mul._eval_is_integer.<locals>.<lambda>  s    3333r'   c                 &    [        S U  5       5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frG   is_evenr  s     r(   rK   r&         51a		1rM   r'  r(  s    r(   r   r)        C5155r'   c                 &    [        S U  5       5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frG   r,  r  s     r(   rK   r&    r.  rM   )r   r(  s    r(   r   r)    r/  r'   r   )is_gtc              3   R   >#    U  H  nT" U[         R                  5      v   M     g 7frG   )r   r2   )rJ   _r2  s     r(   rK   'Mul._eval_is_integer.<locals>.<genexpr>  s       37)5Aa   $'rb   r   )r  r.   r   r   r   r2   r6   r   r   r   r   r   r   r   rZ   r   r   
relationalr2  r  r7   r   r   r-  rh   r   r   is_nonnegative)rO   r  
numeratorsdenominatorsunknownr=   hitr   rm   rk   rl   alloddallevenanyevenr   r2  s                  @r(   _eval_is_integerMul._eval_is_integerq  s   ,,.%
AC||q6&%%a( ''')q6&%%a(AEE> ''* "}}||1<<$((C== ''Q!&&[Aq}}-/ }},, yy(= 9 < G355%ls 37)537 07 07JGL$9$9Z  \aS%8Z  VL & &L959A=+|!QA||		 "1" 23&'ii -!--/!,"1 24<QSSMB(.)  z?a1A||		 $3$ 23()		 -!--/!,$3 46>qssmD%+& !& !*|  	13s   /N&N&N+!N+c                     [        S U R                   5       5      nU=(       a    [        S U R                   5       5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frG   )is_polarrJ   rY  s     r(   rK   %Mul._eval_is_polar.<locals>.<genexpr>  s     :		rM   c              3   ^   #    U  H#  oR                   =(       d    UR                  v   M%     g 7frG   )rD  r   rE  s     r(   rK   rF    s     E9C//9r  )r   r.   r  )rO   	has_polars     r(   _eval_is_polarMul._eval_is_polar  s7    :		::	 FE499EE	Fr'   c                 $    U R                  S5      $ NT)_eval_real_imagr  s    r(   _eval_is_extended_realMul._eval_is_extended_real  s    ##D))r'   c                    SnS nU R                    H  nUR                  =(       d    UR                  SL a  UR                  SL a    gUR                  (       a	  U(       + nMP  UR                  (       aS  U(       dJ  UR
                  nU(       d	  USL a  UnM  U(       a%  [        S U R                    5       5      (       a    g  g M  M  UR                  SL a  U(       a    g UnM  UR                  SL a  U(       a    g UnM    g    U(       a2  UR                  SL a	  U(       a  U$ UR                  SL a
  U(       d  U$ g g USL a  U$ U(       a  U$ g )NFc              3   8   #    U  H  oR                   v   M     g 7frG   r   rI   s     r(   rK   &Mul._eval_real_imag.<locals>.<genexpr>  s     >Iq{{IrM   T)r.   r  r  r   r   r   r  )rO   realzerot_not_re_imrq   zs         r(   rM  Mul._eval_real_imag  s$   A-%7A<N<NRW<Wx##		A >DII>>>#' 	  ##u,5(1 4 ++u4K''50K  1 U]KK r'   c                 h    [        S U R                   5       5      (       a  U R                  S5      $ g )Nc              3   b   #    U  H%  oR                   S L =(       a    UR                  v   M'     g7fr   )r   r   rI   s     r(   rK   )Mul._eval_is_imaginary.<locals>.<genexpr>  s#     E9ayyE!1akk19s   -/F)r  r.   rM  r  s    r(   _eval_is_imaginaryMul._eval_is_imaginary  s.    E499EEE''.. Fr'   c                 $    U R                  S5      $ rL  _eval_herm_antihermr  s    r(   _eval_is_hermitianMul._eval_is_hermitian  s    ''--r'   c                 $    U R                  S5      $ NFr^  r  s    r(   _eval_is_antihermitianMul._eval_is_antihermitian  s    ''..r'   c                    U R                    HL  nUR                  b  UR                  c    g UR                  (       a  M2  UR                  (       a	  U(       + nML    g    USLa  U$ U R                  5       nU(       a  gUSL a  U$ g r	  )r.   is_hermitianis_antihermitianr  )rO   hermrq   r   s       r(   r_  Mul._eval_herm_antiherm  sz    A~~%););)C~~##x  uK$$&K r'   c                     U R                    H\  nUR                  nU(       aA  [        U R                   5      nUR                  U5        [	        S U 5       5      (       a    g  g Ub  M\    g    [	        S U R                    5       5      (       a  gg )Nc              3   t   #    U  H.  oR                   =(       a    [        UR                  5      S L v   M0     g7f)TN)r  r   r   rJ   r   s     r(   rK   *Mul._eval_is_irrational.<locals>.<genexpr>  s'     XQWA>)AII*>4GQWs   68Tc              3   8   #    U  H  oR                   v   M     g 7frG   )is_realrm  s     r(   rK   rn    s     ,)Qyy)rM   F)r.   is_irrationalr1   remover  )rO   rq   r=   otherss       r(   _eval_is_irrationalMul._eval_is_irrational  st    AAdiia XQWXXXy  ,$)),,, -r'   c                 $    U R                  S5      $ )a3  Return True if self is positive, False if not, and None if it
cannot be determined.

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

This algorithm is non-recursive and works by keeping track of the
sign which changes when a negative or nonpositive is encountered.
Whether a nonpositive or nonnegative is seen is also tracked since
the presence of these makes it impossible to return True, but
possible to return False if the end result is nonpositive. e.g.

    pos * neg * nonpositive -> pos or zero -> None is returned
    pos * neg * nonnegative -> neg or zero -> False is returned
r   _eval_pos_negr  s    r(   _eval_is_extended_positiveMul._eval_is_extended_positive  s      !!!$$r'   c                    S=p#U R                    H  nUR                  (       a  M  UR                  (       a  U* nM,  UR                  (       a%  [	        S U R                    5       5      (       a    g  g UR
                  (       a  U* nSnMz  UR                  (       a  SnM  UR                  SL a  U* nU(       a    g SnM  UR                  SL a  U(       a    g SnM    g    US:X  a  USL a  USL a  gUS:  a  gg )NFc              3   8   #    U  H  oR                   v   M     g 7frG   r   rI   s     r(   rK   $Mul._eval_pos_neg.<locals>.<genexpr>7  s     6Iq{{IrM   Tr   r   )	r.   rz   rS   r   r  is_extended_nonpositiveis_extended_nonnegativer   r   )rO   r   saw_NONsaw_NOTrq   s        r(   rx  Mul._eval_pos_neg/  s    !!A%%''u6DII666 **u** %'u%'7 8 19E)g.>!8 r'   c                 $    U R                  S5      $ rx   rw  r  s    r(   _eval_is_extended_negativeMul._eval_is_extended_negativeR  s    !!"%%r'   c                    U R                  5       nUSLa  U$ SSKJn  U" U 5      u  p4UR                  (       a  UR                  (       aw  [        [        R                  U5       Vs/ s H)  nUR                  (       d  M  UR                  5       S   PM+     sn6 [        UR                  5      -
  R                  (       a  gg Su  pgU R                   Hg  n[        U5      [        R                  L a  M!  UR                  (       a    gUSL a  O+US:w  a  Xx-   R                   (       a  SnOUR                  c  S nUnMi     U$ s  snf )NTr   r+  r   F)Tr   )r@  r0  r,  r   r-  rh   r7   r   r   r   r   r   r.   r   r   r2   r%  )	rO   r   r,  r   rm   r   r   accrq   s	            r(   _eval_is_oddMul._eval_is_oddU  s   **,
T!3~<<AII MM!$3$ ./()		 )ammoa($3 46>qssmD!k" A1vyyEzsw.."C  %3s   &D>?D>c                 b   SSK Jn  U" U 5      u  p#UR                  (       a  UR                  (       aw  [	        [
        R                  U5       Vs/ s H)  nUR                  (       d  M  UR                  5       S   PM+     sn6 [        UR                  5      -
  R                  (       a  gg g g s  snf )Nr   r+  r   F)r0  r,  r   r-  rh   r7   r   r   r   r   r8  )rO   r,  r   rm   r   s        r(   _eval_is_evenMul._eval_is_evens  s    3~<<AII MM!$3$ ./()		 )ammoa($3 46>qssmD$n% %	 &<3s   B,(B,c                     SnU R                    HB  nUR                  (       a  UR                  (       d    gUS-
  R                  (       d  M=  US-  nMD     US:  a  gg)z
Here we count the number of arguments that have a minimum value
greater than two.
If there are more than one of such a symbol then the result is composite.
Else, the result cannot be determined.
r   Nr   T)r.   r   r   )rO   number_of_argsrY  s      r(   _eval_is_compositeMul._eval_is_composite  sS     99CNNsA"""!#	  A r'   c           	        ^(^)^*^+^, SSK Jm,  SSKJn  SSKJm+  SSKJn  UR                  (       d  g UR                  S   R                  (       aY  UR                  S   S:  aF  U R                  S   R                  (       a(  U R                  S   S:  a  U R                  U* U* 5      $ g S m(U(U+4S jnU(4S jnS	 nS nU" U 5      u  pU nU
[        R                  LaL  U	R                  X5      U
R                  X5      -  nUR                  (       d  UR                  X5      $ X:w  a  UnUR                  S   nUR                  S   nS nUR                  (       a(  UR                  (       a  X:w  a  UR                  U5      nOUR                  (       a  U$ U" U5      u  m)nU" U5      u  m*nU(       am  UR                  (       a\  [!        U5      S
:w  aM  [        U" [!        U5      U5      5      nT)R#                  U5        UT);   a  T)U==   U-  ss'   OUT)U'   XU-  -  nOS
nSn[%        U5      [%        U5      :  a  SnO[%        T*5      [%        T)5      :  a  SnOU Vs1 s H  nUS   iM
     snR'                  U Vs1 s H  nUS   iM
     sn5      (       a  SnOI[)        T*5      R'                  [)        T)5      5      (       a  SnO[+        U)U*U,4S jT* 5       5      (       a  SnU(       d  U$ T*(       d  S nOR/ nT*R-                  5        H1  u  nnT)U   nUR/                  U" UU5      5        US   (       a  M/  Us  $    [1        U5      nU(       d*  S n[3        [%        U5      5       H  nU" UU   6 UU'   M     GOSn[%        U5      nU=(       d    [        R4                  n/ nSnU(       Ga  UU-   [%        U5      ::  Ga  Sn/ n[3        U5       H  nUUU-      S   UU   S   :w  a    GOUS:X  a(  UR/                  U" UUU-      S
   UU   S
   5      5        OZUUS
-
  :X  a(  UR/                  U" UUU-      S
   UU   S
   5      5        O)UUU-      S
   UU   S
   :w  a    GOUR/                  S
5        US
-  nM     [1        U5      n U (       a  US
:X  aE  U(       a  [1        UU 5      n [7        UU 5      U" UU   S   UU   S
   U US   S
   -  -
  5      -  UU'   OS
n U" UU   S   UU   S
   U US   S
   -  -
  5      n!Un"UU-   S
-
  n#UU#   S   UU#   S
   U US   S
   -  -
  4n$U$S
   (       a5  UU-   [%        U5      :  a  U!U"-  U$/UUUU-   & O!U" U$6 n$U!U"-  U$-  /UUUU-   & OU!U"-  /UUUU-   & UU -  nUU -  nSnU(       d  UR/                  U5        US
-  nU(       a  UU-   [%        U5      ::  a  GM  U(       d  U$ UR9                  [3        U[%        U5      5      5        U H  nU" UU   6 R;                  X5      UU'   M     Uc  Un%OUc  Un%O[1        UU5      n%/ n&T) H[  nUT*;   a(  T)U   T*U   U%-  -
  n'U&R/                  U" UU'5      5        M1  U&R/                  U" UR;                  X5      T)U   5      5        M]     U(       a  U(       d  [7        UU5      /U&-   n&UUR<                  " U&6 -  UR<                  " U6 -  $ s  snf s  snf )Nr   r   )multiplicity)	powdenestr+  c                     SSK Jn  U R                  (       d  [        X5      (       a  U R	                  5       $ U [
        R                  4$ )Nr   )r~  )&sympy.functions.elementary.exponentialr~  r   r   r   r   r2   )r=   r~  s     r(   base_exp Mul._eval_subs.<locals>.base_exp  s2     Cxx:a--}}&aee8Or'   c                 R  > [        [        5      / p![        R                  U 5       H{  nT	" U5      nT" U5      u  pEU[        R
                  La"  UR                  5       u  pg[        XEU-  5      nUnUR                  (       a  X==   U-  ss'   Mi  UR                  XE/5        M}     X4$ )zbreak up powers of eq when treated as a Mul:
   b**(Rational*e) -> b**e, Rational
commutatives come back as a dictionary {b**e: Rational}
noncommutatives come back as a list [(b**e, Rational)]
)
r   rN  r7   r   r   r2   rX   r   r%   r6   )
eqr>   r?   r=   rk   rl   r<   r4  r  r  s
           r(   breakupMul._eval_subs.<locals>.breakup  s     #3']]2&aL!!AEE>nn.GRAtAA##DAIDIIqf% ' 7Nr'   c                 4   > T" U 5      u  p[        XU-  5      $ )z
Put rational back with exponent; in general this is not ok, but
since we took it from the exponent for analysis, it's ok to put
it back.
r   )rk   r<   rl   r  s      r(   rejoinMul._eval_subs.<locals>.rejoin  s     a[FQqB$<r'   c                     UR                   U R                   -  (       a  U R                   UR                   -  (       d  [        X-  5      $ g)zif b divides a in an extractive way (like 1/4 divides 1/2
but not vice versa, and 2/5 does not divide 1/3) then return
the integer number of times it divides, else return 0.
r   )r   rN  )r=   rk   s     r(   ndivMul._eval_subs.<locals>.ndiv  s/    
 339ACC!##I13xr'   r   TFc              3   R   >#    U  H  nT" TU   5      T" TU   5      :g  v   M     g 7frG   r   )rJ   rk   r>   old_cr   s     r(   rK   !Mul._eval_subs.<locals>.<genexpr>  s&     =u!adtE!H~-ur6  ry   )r   r   sympy.ntheory.factor_r  sympy.simplify.powsimpr  r0  r,  r"   r.   r#   _subsr   r2   r   extract_multiplicativelyr   r3   r   
differencesetr   rg   r6   minr   r   r   r5   rb  r  )-rO   ru  newr  r,  r  r  r  r   r   rm   self2co_selfco_oldco_xmulr?   old_ncr  co_residualokr   cdidratrk   old_ec_encdidtakelimitfailedr<  r   ndor\  midirr   domargsrl   r  r>   r  r  r   s-                                           @@@@@r(   
_eval_subsMul._eval_subs  s   =643zz 88A;  SXXa[1_yy|%%99Q<!#::sdSD11		*	 	 ~AEE>GGC%aggc&77E<<{{3,,} **Q-!'"5"5  !::6BI %.B!#, w**s6{a/?\#f+w78DEE'N{&	T!	 &	!$,.KK v;R BZ#a& B"#FqadF#..b/Ab!b/ABBBZ""3q6**B=u===BIDC#kkm
Ed

4U+,2wwI	 ,
 s8DE3r7^11 $ Ev;D&AJJEFAAHB/ tA!a%y|vay|3a

41q5	!fQil#CDdQh

41q5	!fQil#CDAE115

1FA % c(C19#&)$n$'SM&Aq$&qE!Hs6!9Q</?$?3A %ABqE #$C !'r!uQxAqC$*1IaL=1 21 !2A
 #&C "#TAB!#BBrF1I!'A9/ -/ !0A t#$t8c"g#567eQZBqTN(.
A67eAgYBqTN
 34C%1QX" MM!$QC AHB/H I eAs2w/0A"BqEN//9BqE  
 <B]BUD!BAEz aD58B;&VAq\*VAFF3$4ad;<   d^$u,E5::u--ejj"o==U $/As   Z8:Z=c                   ^  SSK Jn  SSKJn  SSKJn  S n/ n	 U R                   HD  n
U
R                  U5      u  pUR                  U5      (       d  U	R                  X45        M@  [        e   [        S U	 5       5      n/ nU	 Hh  u  pU" X--
  UR                  (       a  UOS-   5      nU
R                  UUX4S9nUR                  5       nUb  UU:  a  UUU-
  -  nUR                  U5        Mj     [&        R(                  nU Vs/ s H  n[2        R4                  " U5      PM     nn[7        U6  HY  nU Vs/ s H  nU" UU5      PM     nn[9        U6 u  nn[        U5      nUU-
  R:                  (       d  MH  U[=        U6 UU-  -  -  nM[     U 4S jm U R?                  U5      (       a<  SSK J!n  SSK"J#n   T " X5      U:  d  U" X5      U" UU5      :w  a  UU" X-  U5      -  nU$ UU :w  aa  U U-
  RI                  US5      [&        R(                  :X  a,  US:  a&  U RK                  XUS9nU[&        R(                  :X  a  U$ UU" X-  U5      -  nU$ ! [        [        [         U4 a    [#        [        S	 U	 5       5      5      nUR$                  (       a  [&        R(                  nU R                   V
s/ s H  oR                  X" X--
  5      X4S9PM     Os  sn
f nn
SS
KJn  U" U R.                  " U6 R1                  5       SSS9nUR                  U5      (       a  UU" X-  U5      -  nUs $ f = fs  snf s  snf ! U a     GNZf = f)Nr   )	PoleErrorr   )ceiling)Orderc                     U R                  U5      nUS   R                  U5      (       a   U R                  U5      nU$ U$ ! [         a    U [        R
                  4s $ f = frW   )as_coeff_exponentr   leadterm
ValueErrorr   r   )r6  r   lts      r(   	coeff_exp$Mul._eval_nseries.<locals>.coeff_exp  s`    ''*B!uyy||(q)B I2I " (<'(s   A A A c              3   V   #    U  H  oS    R                   (       d  M  US    v   M!     g7fr   Nr   rJ   rq   s     r(   rK   $Mul._eval_nseries.<locals>.<genexpr>  s     :4aQ4>>TQqT4   )))r   logxcdirc              3   V   #    U  H  oS    R                   (       d  M  US    v   M!     g7fr  r  r  s     r(   rK   r    s     B4aQ4>>TQqT4r  )powsimpr~  T)combiner  c           	        >^ U TL a  [         R                  $ U R                  (       a  [         R                  $ U R                  (       a   [        UU4S jU R                   5       5      $ U R                  (       a*  [        U R                   Vs/ s H  nT" UT5      PM     sn6 $ U R                  (       a   T" U R                  T5      U R                  -  $ [         R                  $ s  snf )Nc              3   6   >#    U  H  nT" UT5      v   M     g 7frG   r   )rJ   r=   
max_degreer   s     r(   rK   8Mul._eval_nseries.<locals>.max_degree.<locals>.<genexpr>  s     <V:a++Vs   )r   r2   is_Atomr   r   maxr.   r"   rh   r   r  r~  )rl   r   r=   r  s    ` r(   r  %Mul._eval_nseries.<locals>.max_degree  s    Avuuyyvvxx<QVV<<<xxqvv>v!Z1-v>??xx!!&&!,QUU2266M ?s   C&)PolynomialError)degreer  r  )&r  r  #sympy.functions.elementary.integersr  sympy.series.orderr  r.   r  r   r6   r  rT  r   nseriesgetnNotImplementedError	TypeErrorr   r8  r   r   r  r  r  r   rh   r   r   rP  r   r7   is_polynomialsympy.polys.polyerrorsr  sympy.polys.polytoolsr  rb  _eval_as_leading_term)!rO   r   r   r  r  r  r  r  r  ordsrq   r   r~  n0facsr   n1r>  nsr  resr5  ords2facr6  ords3coeffspowerspowerr  r  r  r  s!                                   @r(   _eval_nseriesMul._eval_nseries  s   '?,	 	YYZZ]
yy||KK)$$  :4::BDQVAKKqQ?@IIa2DI<VVX>BwR"WA . ff59:T6v&T:E?C478CDYtQ'CE8 %[NFFKE	&&&sF|QX.. #	 a  >4d&!+vd&a./P5q>)C 
$;s
  A&!&&0QU//4/H<J5q>!C
m /IF 	 B4BBCB  VVQUQZQZ[QZAIIa714=tIGQZ[D[6$))T*113UNCwwu~~uQT1~%J	 ; 92 # s>   CI  L*5L/4-L4 A L',!KAL'&L'4L>=L>c                 z    U R                   " U R                   Vs/ s H  oDR                  XUS9PM     sn6 $ s  snf )Nr  )r  r.   as_leading_term)rO   r   r  r  rq   s        r(   r  Mul._eval_as_leading_term  s5    yytyyYy!,,Q,EyYZZY   8c                 z    U R                   " U R                   Vs/ s H  oR                  5       PM     sn6 $ s  snf rG   )r  r.   r  rO   rq   s     r(   _eval_conjugateMul._eval_conjugate  s+    yy$))<)Q;;=)<==<r  c                     U R                   " U R                  S S S2    Vs/ s H  oR                  5       PM     sn6 $ s  snf rx   )r  r.   	transposer  s     r(   _eval_transposeMul._eval_transpose  s3    yy$))DbD/B/Q;;=/BCCB   >c                     U R                   " U R                  S S S2    Vs/ s H  oR                  5       PM     sn6 $ s  snf rx   )r  r.   adjointr  s     r(   _eval_adjointMul._eval_adjoint  s3    yy		$B$@199;@AA@r  c                     [         R                  n/ nU R                   H>  nUR                  XS9u  pgX6-  nU[         R                  Ld  M-  UR	                  U5        M@     X0R
                  " U6 4$ )a  Return the tuple (R, self/R) where R is the positive Rational
extracted from self.

Examples
========

>>> from sympy import sqrt
>>> (-3*sqrt(2)*(2 - 2*sqrt(2))).as_content_primitive()
(6, -sqrt(2)*(1 - sqrt(2)))

See docstring of Expr.as_content_primitive for more examples.
)radicalclear)r   r2   r.   as_content_primitiver6   r  )rO   r  r  coefr.   r=   r>   r   s           r(   r  Mul.as_content_primitive  sf     uuA))')GDAID~A	  YY%%%r'   c                 V   ^ U R                  5       u  p#UR                  U4S jS9  X#-   $ )zTransform an expression into an ordered list of factors.

Examples
========

>>> from sympy import sin, cos
>>> from sympy.abc import x, y

>>> (2*x*y*sin(x)*cos(x)).as_ordered_factors()
[2, x, y, sin(x), cos(x)]

c                 "   > U R                  TS9$ )N)order)sort_key)r2  r  s    r(   r   (Mul.as_ordered_factors.<locals>.<lambda>'  s    DMMM$>r'   r*   )r4   r,   )rO   r  cpartncparts    `  r(   as_ordered_factorsMul.as_ordered_factors  s)     

>
?~r'   c                 4    [        U R                  5       5      $ rG   )r  r  r  s    r(   _sorted_argsMul._sorted_args*  s    T,,.//r'   )F)Trc  rG   )r   rW   )FT)Sr   r   r   r    __doc__	__slots__tTupler   __annotations__r"   
_args_typer   rN   propertyrH   rT   r[   classmethodr   r   r   r   r   r   r   rX   re   r   staticmethodr"  r1  r?  rM  rg  rn  rk  rs  rt  r  r  r  r  rj  r  r   r   r  r  r  r  _eval_is_commutativer  r  r  r  r  r   r@  rI  rN  rM  r[  r`  rd  r_  rt  ry  rx  r  r  r  r  r  r  r  r  r  r  r  r  r  r&   __classcell__)r]  s   @r(   r7   r7   [   s   DJ I
s
FJ%&;N1 16
: I. I.V8 " "  6 6 9 9< +/ 
 
 5:n $ $$)V 	# 	#  >!@   ( (T < < 2 2h & & E E
 ', ',R6%IP-M-A(F

L!\F
*(T/./(%$!F&<
"F>PYv[>DB&4" 0 0r'   r7   mulc                 6    [        [        R                  X5      $ )aK  Return product of elements of a. Start with int 1 so if only
   ints are included then an int result is returned.

Examples
========

>>> from sympy import prod, S
>>> prod(range(3))
0
>>> type(_) is int
True
>>> prod([S(2), 3])
6
>>> _.is_Integer
True

You can start the product at something other than 1:

>>> prod([1, 2], 3)
6

)r   operatorr)  )r=   starts     r(   rU  rU  1  s    . (,,))r'   c           
      h   U R                   (       d  UR                   (       a  XpOX-  $ U[        R                  L a  U $ U [        R                  L a  U$ U [        R                  L a
  U(       d  U* $ UR                  (       a  U(       d  U R
                  (       a  U R                  S:w  a  UR                   Vs/ s H  oDR                  5       PM     nnU VVs/ s H  u  pg[        X`5      U4PM     nnn[        S U 5       5      (       aH  [        R                  " U Vs/ s H&  n[        R                  US   S:X  a  USS OU5      PM(     sn5      $ [        XSS9$ UR                  (       ax  [        UR                  5      nUS   R                   (       a(  US==   U -  ss'   US   S:X  a  UR!                  S5        OUR#                  SU 5        [        R                  U5      $ X-  nUR                   (       a'  UR                   (       d  [        R                  X45      nU$ s  snf s  snnf s  snf )a  Return ``coeff*factors`` unevaluated if necessary.

If ``clear`` is False, do not keep the coefficient as a factor
if it can be distributed on a single factor such that one or
more terms will still have integer coefficients.

If ``sign`` is True, allow a coefficient of -1 to remain factored out.

Examples
========

>>> from sympy.core.mul import _keep_coeff
>>> from sympy.abc import x, y
>>> from sympy import S

>>> _keep_coeff(S.Half, x + 2)
(x + 2)/2
>>> _keep_coeff(S.Half, x + 2, clear=False)
x/2 + 1
>>> _keep_coeff(S.Half, (x + 2)*y, clear=False)
y*(x + 2)/2
>>> _keep_coeff(S(-1), x + y)
-x - y
>>> _keep_coeff(S(-1), x + y, sign=True)
-(x + y)
r   c              3   >   #    U  H  u  pUR                   v   M     g 7frG   )r   )rJ   r>   r4  s      r(   rK   _keep_coeff.<locals>.<genexpr>u  s     1DDA1<<Dr   r   NFra   )r#   r   r2   rZ   r   r   r   r.   re   r   r   rh   r8   r7   r"   r1   r3   r9   )	r   factorsr  r   r   r.   r>   r   r  s	            r(   r   r   K  s   6 ??"U= !%%~	!--	x	**uww!|.5ll;lNN$lD;;?@441[*A.4D@1D111~~8<'>8<1 (+~~qTQYAabEA(/8<'> ? ?5E22	W\\"8!HHQx1}		!LLE"~~e$$M;;w00/0A' <@'>s   8H$H)-H/c                     S n[        X5      $ )Nc                     U R                   (       aY  U R                  5       u  pUR                  (       a6  UR                  (       a%  [	        UR
                   Vs/ s H  o1U-  PM	     sn6 $ U $ s  snf rG   )r"   re   r#   r   _unevaluated_Addr.   )rl   r>   r   ris       r(   r  expand_2arg.<locals>.do  sO    88>>#DA{{qxx')@2B$)@AA *As   A-r   )rl   r  s     r(   expand_2argr6    s     Qr'   )r   r  )rh   r3  )r   )TF)4typingr   r!  collectionsr   	functoolsr   	itertoolsr   r+  r   basicr	   r
   	singletonr   
operationsr   r   cacher   intfuncr   r   logicr   r   r2  r   
parametersr   rH   r   	traversalr   sympy.utilities.iterablesr   r   r/   r@   r7   r)  rU  r   r6  r   r   r  r   addrh   r3  r   r'   r(   <module>rE     s    " #     '  2  . *  )     * !
3#lQ0$ Q0f> *4;z   & &r'   