
    g2                    b   d dl mZ d dlmZ d dlmZ d dlmZ d dl	Z	ddl
m
Z
 ddlmZmZ dd	lmZ dd
lmZmZ ddlmZ ddlmZmZ ddlmZmZ ddlmZ ddlmZ ddlm Z  ddl!m"Z" d dl#m$Z$  G d d      Z%d Z&d Z' G d dee      Z( ed      Z)d dZ*d!dZ+d Z,ddl-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3 y)"    )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                        e Zd ZdZdZdZdZdZy)	NC_MarkerFN)__name__
__module____qualname__is_Orderis_Mul	is_Numberis_Polyis_commutative     C/var/www/openai/venv/lib/python3.12/site-packages/sympy/core/mul.pyr   r      s    HFIGNr$   r   c                 0    | j                  t               y )Nkey)sortr
   argss    r%   _mulsortr,       s    II-I r$   c                  2   t        |       } g }g }t        j                  }| r| j                         }|j                  rK|j                         \  }}| j                  |       |rH|j                  t        j                  |             n#|j                  r||z  }n|j                  |       | rt        |       |t        j                  ur|j                  d|       |r$|j                  t        j                  |             t        j                  |      S )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JJLEArKKNcnnR01[[!GBNN1  W	q"s~~f-.>>'""r$   c                       e Zd ZU dZdZeedf   ed<   dZeZ	 e
dd      Zed        Zd	 Zd
 Zed        Zd Zed        Zd Zed        Zed        Zeddd       ZdIdZdJdZed        Zd Zed        Ze fd       Zd Z d Z!dKdZ"ed        Z#edLd       Z$ed        Z%ed        Z&ed         Z'ed!        Z(ed"        Z)d# Z*d$ Z+d% Z,d& Z-d' Z.d( Z/d) Z0d* Z1d+ Z2d, Z3d- Z4d. Z5d/ Z6d0 Z7d1 Z8d2 Z9d3 Z:d4 Z;d5 Z<d6 Z=d7 Z>d8 Z?d9 Z@d: ZAd; ZBd< ZCd= ZDd> ZEd? ZFd@ ZGdMdAZHdNdBZIdC ZJdD ZKdE ZLdOdFZMdLdGZNedH        ZO xZPS )Pr4   aB  
    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    d | j                   D        } | j                  | S )Nc              3   4   K   | ]  }|j                     y wN)kind.0r:   s     r%   	<genexpr>zMul.kind.<locals>.<genexpr>   s     /YQVVY   )r+   _kind_dispatcher)self	arg_kindss     r%   rD   zMul.kind   s#    /TYY/	$t$$i00r$   c                 b    | |  k(  ry| j                   d   }|j                  xr |j                  S )NFr   )r+   r    is_extended_negative)rJ   r;   s     r%   could_extract_minus_signzMul.could_extract_minus_sign   s0    TE?IIaL{{5q555r$   c                 H   | j                         \  }}|d   t        j                  ur| }|t        j                  urJ|d   j                  r5t        |      }|t        j                  u r
|d    |d<   n|dxx   |z  cc<   n|f|z   }| j                  || j                        S Nr   )	as_coeff_mulr   ComplexInfinityr/   r    r.   NegativeOner5   r"   )rJ   r;   r+   s      r%   __neg__zMul.__neg__   s    ##%47!+++AAEE>Aw  Dz%#AwhDGGqLGtd{tT%8%899r$   c           
      (  "6 ddl m} ddlm6 d}t	        |      dk(  r|\  }""j
                  r	"|c}"|"g}|t        j                  usJ |j
                  r|j                  s"j                         \  }""j                  r|t        j                  ur/||z  }|t        j                  u r"}n | ||z  "d      }|gg df}nLt        j                  r<"j                  r0t        "j                  D cg c]  }t!        ||       c} }	|	gg df}|r|S g }
g }g }t        j                  }g }g }t        j"                  }i }d}|D ]  }|j$                  r|j'                  |      \  }}|j(                  r~|j                  r|j+                  |j                         nU|j                  D ]1  }|j                  r|j-                  |       !|j-                  |       3 |j-                  t.               |j0                  r|t        j2                  u s|t        j4                  u r"|j                  rt        j2                  gg dfc S |j0                  st7        ||      r-||z  }|t        j2                  u rt        j2                  gg dfc S Gt7        ||      r|j9                  |      }f|t        j4                  u r*|st        j2                  gg dfc S t        j4                  }|t        j:                  u r|t        j<                  z  }|j                  r|j?                         \  "}|j@                  rԉ"j0                  r|j
                  r|jB                  r|tE        "|      z  }*|jF                  r|j-                  tE        "|             S"jF                  r||z  }" ""t        j                  ur!|jI                  "g       j-                  |       "jJ                  s|jL                  r|j-                  "|f       |j-                  "|f       |t.        ur|j-                  |       |s|jO                  d      }|s|j-                  |       )|jO                         }|j?                         \  }}|j?                         \  }}||z   }||k(  rB|j                  s6||z  }|j                  r|j-                  |       |jQ                  d|       n|j+                  ||g       |r d } ||      } ||      }tS        d      D ]e  }g }d} |D ]   \  "}|j                  rr"j                  s"j(                  rYtU        "fd	t        j4                  t        jV                  t        jX                  fD              rt        j2                  gg dfc c S |t        j                  u r"j0                  r|"z  }"}!|t        j                  ur@tE        "|      }!|!j@                  r("j@                  s"}|!j?                         \  "}"|k7  rd
} |
j-                  !       |j-                  "|f       # | r6t	        |D "ch c]  \  }"}|"	 c}}"      t	        |      k7  rg }
 ||      }f n i }#|D ]&  \  "}|#jI                  |g       j-                  "       ( |#j[                         D ]  \  }" | " |#|<    |
j+                  |#j[                         D "cg c]  \  }}"|s	tE        |"|       c}"}       i }$|j[                         D ],  \  "}|$jI                  t        | g       j-                  "       . ~g }%|$j[                         D ]  \  }" | " "|j\                  dk(  r|tE        "|      z  }*|j^                  |j\                  kD  rHta        |j^                  |j\                        \  }&}'|tE        "|&      z  }tc        |'|j\                        }|%j-                  "|f        ~$te        tf              }(d}|t	        |%      k  r|%|   \  }})|dk(  r|dz  }"g }*tS        |dz   t	        |%            D ]  }+|%|+   \  },}-|ji                  |,      }.|.t        j                  us/|)|-z   }|j\                  dk(  r|tE        |.|      z  }nt|j^                  |j\                  kD  rHta        |j^                  |j\                        \  }&}'|tE        |.|&      z  }tc        |'|j\                        }|*j-                  |.|f       |,|.z  |-f|%|+<   ||.z  }|t        j                  u s n |t        j                  ur{tE        ||)      }/|/j0                  r||/z  }n]tj        jm                  |/      D ]E  }/|/j0                  r||/z  }|/j@                  sJ |/j                  \  }})|(|)   j-                  |       G |%j+                  |*       |dz  }|t	        |%      k  r|(j[                         D ]  \  }" | " |(|<    |r|jo                         \  }!}ta        |!|      \  }0}!|0dz  r| }|dk(  r |
j-                  t        j:                         nk|!ritc        |!|      }|(j[                         D ]  \  }"||k(  s"jJ                  s" |(|<    n, |
j-                  tE        t        jp                  |d             |
j+                  |(j[                         D "cg c]  \  }}"tE        |"|       c}"}       |t        jV                  t        jX                  fv r d }1 |1|
d      \  }
}2 |1||2      \  }}2||2z  }|t        j4                  u ra|
D 3cg c]%  }3ts        |3j                        r|3jt                  |3' }
}3|D 3cg c]%  }3ts        |3j                        r|3jt                  |3' }}3nR|j                  rFtU        6fd|D              r|g||fS tU        d |
D              rt        j2                  gg |fS |gg |fS g }4|
D ]%  }|j0                  r||z  }|4j-                  |       ' |4}
tw        |
       |t        j                  ur|
jQ                  d|       t        j                  ri|sgt	        |
      dk(  rY|
d   j0                  rJ|
d   jx                  r;|
d   j                  r,|
d   }t        |
d   j                  D 5cg c]  }5||5z  	 c}5 g}
|
||fS c c}w c c}}"w c c}"}w c c}"}w c c}3w c c}3w c c}5w )a.  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           
         i }| D ]L  \  }}|j                         }|j                  |i       j                  |d   g       j                  |d          N |j                         D ](  \  }}|j                         D ]  \  }}t	        | ||<    * g }|j                         D ]<  \  }}|j                  |j                         D 	
cg c]  \  }	}
||
|	z  f c}
}	       > |S c c}
}	w Nr   r   )as_coeff_Mul
setdefaultr3   itemsAddr2   )c_powerscommon_bber9   ddilinew_c_powerstr;   s              r%   _gatherzMul.flatten.<locals>._gather  s    H 1^^%##Ar*55qE2%vbe} ! !(1ggiFBHAbE ( ) L (1##!'')$D)$!Qa1X)$DE ) %Es   C"c              3   :   K   | ]  }|j                   v   y wrC   r*   )rF   inftyrc   s     r%   rG   zMul.flatten.<locals>.<genexpr>  s%      6;&:E 7<qvvo&:s   Tr   c                 |    g }| D ]2  }|j                   r|j                  r|dz  }"|j                  |       4 ||fS N)is_extended_positiverM   r3   )c_part
coeff_sign
new_c_partri   s       r%   _handle_for_ooz#Mul.flatten.<locals>._handle_for_oo  sN    
A-- --"b(
 %%a(   ":--r$   c              3   6   K   | ]  }t        |        y wrC   )
isinstance)rF   r;   rW   s     r%   rG   zMul.flatten.<locals>.<genexpr>  s     >g:a,gs   c              3   :   K   | ]  }|j                   d k(    ywFN	is_finite)rF   r;   s     r%   rG   zMul.flatten.<locals>.<genexpr>  s     8A1;;%'   )=!sympy.calculus.accumulationboundsrV   sympy.matrices.expressionsrW   lenis_Rationalr   r/   is_zeror]   is_Addr   
distributer"   r`   r+   _keep_coeffZeror   as_expr_variablesr   r2   r3   r   r    NaNrR   rv   __mul__ImaginaryUnitHalfas_base_expis_Pow
is_IntegerPowis_negativer^   is_positive
is_integerr0   r6   rangeanyInfinityNegativeInfinityr_   qpdivmodRationalr   r.   gcdr4   	make_argsas_numer_denomrS   r   is_extended_realr,   rz   )7clsseqrV   rvr:   rararbbinewbrq   nc_partnc_seqcoeffra   num_expneg1epnum_ratorder_symbolsor   rd   o1b1e1b2e2new_expo12rj   irh   changedr   rc   inv_exp_dictcomb_enum_rate_ieppneweigrowjbjejgobjnrt   rr   r;   _newfrW   s7                                     `                   @r%   flattenzMul.flatten   s   ^ 	B9s8q=DAq}}!1!fAEE>!>}}QYY~~'188~qS;"#C"%ac1u"=C!UB_*55!:J:J"!&&$I&B[B%7&$IJ"VR-	      Azz#$#6#6}#E = xx##JJqvv& VV++JJqM"MM!,	 $ JJy) :!*;*;!;		EE7B,,__
5+(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!$ 

1A"q)  !B^^-FB]]_FB 2gG
 Rx Gm --JJsO$"MM!S1  Aw/7 u H	  8$ '"0 qALG 199AHH# 6;&'&7&7&'&8&8&:6; 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Qs1ay-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Ezamm#$"Q ) MM#ammUU"KL 	TZZ\:\TQs1ay\:; QZZ!3!344	. "0!:FJ"0*"EGZZE A%%% "( QA	!))0D010B0B0N F Q") S'Q)AII2F232D2D2P 'G S ]] >g>>w66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w--M %Jd 0  HJ ;2QSD =s0   4s.s32
s9
=s9
.s?
$*t*t
tc           
         | j                  d      \  }}|j                  rDt        |D cg c]  }t        ||d       c} t        t        j	                  |      |d      z  S |j
                  r|j                  dk(  r| j                  r| j                         d   }|j
                  rt        |dz        j                         \  }}t        |d      \  }}|ret        |d      \  }}|rTddlm}	 t        |      |z  }
t        |
|j                   z  d |	|      t"        j$                  z  z   |j                   z        S t        | |d      }|j
                  s|j&                  r|j)                         S |S c c}w )NF)split_1rY   rX   r   r   sign)r1   r   r4   r   r5   r   r   is_imaginaryas_real_imagabsr   r   $sympy.functions.elementary.complexesr   r   r=   r   r   r   is_Float_eval_expand_power_base)rJ   rd   cargsr<   rc   r:   r   re   ri   r   r   r   s               r%   _eval_powerzMul._eval_power  sJ    MM%M0	r<<EBEqQE2EBCCNN2&E:; ;==QSSAX  %%'*==qs8224DAq*1a0DAq.q!41Q '
1A#3AqssFQaAX=X[\[^[^<^#__a%(==AJJ,,..) Cs   E9c                      dd| j                   fS )N   r   )r   r   s    r%   	class_keyzMul.class_key  s    !S\\!!r$   c                 .   | j                         \  }}|t        j                  u r=|j                  rt	        j
                  ||       }n/|j                  |      }||}| }nt	        j
                  | |      }|j                  r|j                         S |S rC   )r]   r   rS   r   r   _eval_evalf	is_numberexpand)rJ   precr;   mr   mnews         r%   r   zMul._eval_evalf  s      "1xx))!T22}}T*#AR$$T40B<<99;	r$   c                     ddl m} | j                         \  }}|t        j                  urt        d       |d      j                   ||      j                  fS )z;
        Convert self to an mpmath mpc if possible
        r   )Floatz7Cannot convert Mul to mpc. Must be of the form Number*Ir   )numbersr   r]   r   r   AttributeError_mpf_)rJ   r   im_part	imag_units       r%   _mpc_z	Mul._mpc_  sQ    
 	#!..0AOO+ !!Z[[ag 4 455r$   c                     | j                   }t        |      dk(  rt        j                  | fS t        |      dk(  r|S |d    | j                  |dd  fS )ao  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   rX   r   N)r+   r~   r   r/   _new_rawargs)rJ   r+   s     r%   as_two_termszMul.as_two_terms  s[    * yyt9>55$;Y!^K 7-D--tABx888r$   )rationalc                `   r8t        | j                  fdd      \  }} | j                  | t        |      fS | j                  }|d   j                  rG|r|d   j
                  r
|d   |dd  fS |d   j                  rt        j                  |d    f|dd  z   fS t        j                  |fS )Nc                 "     | j                    S rC   )has)xdepss    r%   <lambda>z"Mul.as_coeff_mul.<locals>.<lambda>0  s    uquud|r$   T)binaryr   r   )
r   r+   r   tupler    r   rM   r   rS   r/   )rJ   r   r   kwargsl1l2r+   s     `    r%   rQ   zMul.as_coeff_mul-  s    $))%;DIFB$4$$b)5944yy7tAw22AwQR((a--}}QxkDH&<<<uud{r$   c                 B   | j                   d   | j                   dd }}|j                  rd|r|j                  r&t        |      dk(  r||d   fS | | j                  | fS |j
                  r$t        j                   | j                  | f|z    fS t        j                  | fS )zC
        Efficiently extract the coefficient of a product.
        r   r   N)	r+   r    r   r~   r   rM   r   rS   r/   )rJ   r   r   r+   s       r%   r]   zMul.as_coeff_Mul:  s     iilDIIabMt??u00t9> $q'>) "3$"3"3T":::++}}&7d&7&7E6)d:J&LLLuud{r$   c                    ddl m}m}m} g }g }g }t        j
                  }	| j                  D ]  }
|
j                         \  }}|j                  r|j                  |       4|j                  r#|j                  |t        j                  z         c|
j                  ro|r|
j                         nd }t        |      D ])  \  }}||k(  s|j                   ||      dz         ||=   |
j                  r|	|
z  }	|j                  |
       |j                  |
         | j                  | }|j!                  d      |k(  ry t#        |      dz  r ||j%                  d            }nt        j&                  } | j                  ||z    }| ||      z  | ||      z  }}|	dk(  rY|dk(  r3|j                  r|t        j&                  fS t        j&                  ||z  fS |t        j&                  u r||fS | |z  ||z  fS ddlm}  ||	d      j                         \  }}|t        j&                  u r||z  ||z  z
  ||z  ||z  z   fS | |z  ||z  }}||z  ||z  z
  ||z  ||z  z   fS )	Nr   )AbsimrerX   ignorer   )
expand_mulF)deep)r   r   r   r   r   r/   r+   r   r   r3   r   r"   	conjugate	enumerater   funcgetr~   r0   r   functionr   )rJ   r   hintsr   r   r   othercoeffrcoeffiaddtermsr:   r   r   aconjr   r   imcorecor   addreaddims                        r%   r   zMul.as_real_imagJ  sC   DD55A>>#DAqyya a/0!!).D%e,DAqEzc!fai0!!H	 - xx AQQ) * DIIu99X!#v;?fjjm$D 66Dtyy6F?,RU
DAJ1q=Av<< !&&>)FFDI..qvv~1vE!GT!V$$(!(7DDFu166>eGag%qw5'89957DFqAeGag%qw5'899r$   c           	      :   t        |       }|dk(  r| d   j                  S g }t        j                  | d|dz         }t        j                  | |dz  d       }|D cg c]  }|D ]  }t        ||        }}}t	        | }t	        j
                  |      S c c}}w )zk
        Helper function for _eval_expand_mul.

        sums must be a list of instances of Basic.
        r   r   NrX   )r~   r+   r4   _expandsumsr`   r   )sumsLtermsleftrightr:   rc   addeds           r%   r  zMul._expandsums  s     I67<<tEQT{+QTU,$(8Dq%QQ%D8U}}U## 9s   Bc                 :   ddl m} | } |||j                  dd            \  }}|j                  r3||fD cg c]"  }|j                  r |j                  di |n|$ c}\  }}||z  }|j                  s|S g g d}	}}|j
                  D ]Z  }
|
j                  r|j                  |
       d}	#|
j                  r|j                  |
       A|j                  t        |
             \ |	s|S  | j                  | }|r|j                  dd      }| j                  j                  |      }g }|D ]_  }| j                  ||      }|j                  r.t        d |j
                  D              r|r|j	                         }|j                  |       a t        | S |S c c}w )	Nr   fractionexactFTr   c              3   4   K   | ]  }|j                     y wrC   )r   rE   s     r%   rG   z'Mul._eval_expand_mul.<locals>.<genexpr>  s     'A&Q&rH   r#   )sympy.simplify.radsimpr  r   r   _eval_expand_mulr+   r   r3   r"   r	   r   r  r   r`   )rJ   r  r  exprr   re   r   plainr  rewritefactorr   r  r+   termri   s                   r%   r  zMul._eval_expand_mul  s   3 eii78188Q!A 4588&A&&//B!DAqs{{K!2uWtiiF}}F#((LL(KKf.   KDIIu%Eyy/		--d3!D		%.AxxC'A!&&'A$Ad..0KKN	 "
 Dz!A!s   'Fc           
      0   t        | j                        }g }t        t        |            D ]T  }||   j	                  |      }|s|j                  t        d |d | |gz   ||dz   d  z   t        j                               V t        j                  |      S )Nc                     | |z  S rC   r#   )r   ys     r%   r   z&Mul._eval_derivative.<locals>.<lambda>  s    1r$   r   )r.   r+   r   r~   diffr3   r   r   r/   r`   fromiter)rJ   sr+   r  r   re   s         r%   _eval_derivativezMul._eval_derivative  s    DIIs4y!AQQA V$4tBQx1#~QQRUV7TWXW\W\]^ " ||E""r$   c                 H   ddl m} ddlm}m}m} t        |||f      st        | !  ||      S ddl	m
} | j                  }t        |      }	t        |t        |f      rkg }
ddlm}  ||	|      D ]O  \  }}t!        t#        ||      D cg c]  \  }}|j%                  ||f       c}} }|
j'                  ||z         Q t)        |
 S ddlm} ddlm} dd	lm}  |d
|	z  |      }|t7        |      z
  } ||      }|t9        t;        ||            z   ||      z  t!        t=        |	dz
        D cg c]  }||   j%                  |||   f       c} z  |d   j%                  | |d|      f      z  |D cg c]  }|d|f	 c}}} ||g| S c c}}w c c}w c c}w )Nr   )AppliedUndef)SymbolsymbolsDummy)Integerr   )!multinomial_coefficients_iterator)Sum)	factorial)Maxzk1:%ir   ro   )r  r(  symbolr)  r*  r+  rv   super_eval_derivative_n_timesr   r,  r+   r~   intsympy.ntheory.multinomialr-  r4   zipr#  r3   r`   sympy.concrete.summationsr.  (sympy.functions.combinatorial.factorialsr/  (sympy.functions.elementary.miscellaneousr0  sumprodmapr   )rJ   r%  r   r(  r)  r*  r+  r,  r+   r   r  r-  kvalsr;   kargr   r.  r/  r0  klastnfactri   rd   l	__class__s                            r%   r3  zMul._eval_derivative_n_times  s   *22!lF34 73Aq99$yyIa#w(ES=aCqUD9IJ9Ivq##((Aq6*9IJKQU# D ;1F@!/CJ!$s9e,--i.>>uQqSzBz!$q',,58}-zBCDHMM1c!Um,-. !&&1aAY&	 
 1zqz K C&s   
F4 F
;Fc                     ddl m} | j                  d   }t        | j                  dd   }|j	                  |||z          ||||      z   ||||      |z  z   S )Nr   )difference_deltar   )sympy.series.limitseqrE  r+   r4   subs)rJ   r   stepddarg0rests         r%   _eval_difference_deltazMul._eval_difference_delta  sc    @yy|DIIabM"		!QX&D!T)::Ra=N>  	r$   c                     | j                         \  }}t        j                  |      }t        |      dk(  r1| j                  j                  ||      }|d   j                  ||      S y r\   )r]   r4   r   r~   rC  _combine_inversematches)rJ   r  	repl_dictr   r  newexprs         r%   _matches_simplezMul._matches_simple  s]    ((*ue$u:?nn55dEBG8##GY77r$   c                    t        |      }| j                  r|j                  r| j                  |||      S | j                  |j                  ury | j                         \  }}|j                         \  }}||fD cg c]	  }|xs dg c}\  }}t	        | }	t	        | }
|	j                  |
||      }|s||k7  ry t        j                  |      }t        j                  |      }t        j                  |||      }|xs d S c c}w Nr   )r   r"   _matches_commutativer1   r4   rO  _matches_expand_pows_matches_noncomm)rJ   r  rP  oldc1nc1c2nc2r;   comm_mul_selfcomm_mul_exprs              r%   rO  zMul.matches  s   t}4#6#6,,T9cBB  (;(;; --/C--/C%'H-Hq!(s(H-B RR!))-CH	 R2X &&s+&&s+((c9=	 D ) .s   <Dc                     g }| D ]X  }|j                   r9|j                  dkD  r*|j                  |j                  g|j                  z         H|j	                  |       Z |S rP   )r   expr2   baser3   )arg_listnew_argsr?  s      r%   rV  zMul._matches_expand_pows  sP    Czzcggk
SWW 45$	 
 r$   c                    |i }n|j                         }g }d}|\  }}i }|t        |      k  r|t        |       k  r| |   }|j                  rt        j	                  ||       t        j                  ||| |      }	|	r'|	\  }
}|j                  |
       |r|D ]
  }||   ||<    |sy|j                         }|\  }}|t        |      k  r|t        |       k  r|S )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_Wildr4   _matches_add_wildcard_matches_new_statesr2   r0   )nodestargetsrP  agendastatenode_ind
target_indwildcard_dictnodestates_matches
new_statesnew_matchesmatchs                r%   rW  zMul._matches_noncomm%  s     I!(I $*3w<'Hs5z,A?D||))-? 44]E5:GEN*8'
Kj)!,+6u+=	%( "-

',$*% 3w<'Hs5z,A( r$   c                 D    |\  }}|| v r| |   \  }}||f| |<   y ||f| |<   y rC   r#   )
dictionaryrl  rm  rn  beginends         r%   rg  zMul._matches_add_wildcardP  s@    $*z!#H-JE3$):#6Jx $.
#;Jx r$   c                    |\  }}||   }||   }|t        |      dz
  k\  r|t        |      dz
  k  ry |j                  rt        j                  | |||      }|rt        j	                  | ||      }	|	D ]>  }
| |
   \  }}| |   \  }}|||dz    }|||dz    }t        ||      D ]  \  }}||k7  s  y  @ ||dz   fg}|t        |      dz
  k  r|j                  |dz   |dz   f       ||fS y |t        |      dz
  k\  r|t        |      dz
  k  ry |j                  |      }|r|dz   |dz   fg|fS ||k(  r|dz   |dz   fgd fS y rT  )r~   rf  r4   _matches_match_wilds_matches_get_other_nodesr6  r3   rO  )rv  rl  ri  rj  rm  rn  rp  targetmatch_attemptother_node_indsindother_begin	other_end
curr_begincurr_endother_targetscurrent_targetscurrr  	new_states                       r%   rh  zMul._matches_new_statesY  s   $*X$ W))hUa.G<<44Z5:GEM #&">">z?Dh#P*C-7_*K+5h+?(J$+K	A$FM&-j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                     ||   }| |   \  }}|||dz    }t        |      dkD  rt        | n|d   }|j                  |      S )z@Determine matches of a wildcard with sub-expression in `target`.r   r   )r~   r4   rO  )	rv  wildcard_indri  rj  wildcardrw  rx  r  mults	            r%   rz  zMul._matches_match_wilds  sV     &-
scAg&!%j1nsE{%(%%r$   c                 H    ||   }| D cg c]  }||   |k(  s| c}S c c}w )z8Find other wildcards that may have already been matched.r#   )rv  ri  rm  ind_noder  s        r%   r{  zMul._matches_get_other_nodes  s0     ?)DzU3Z8-CzDDDs   c                    ddl m} ddlm} | |k(  rt        j
                  S d } || |      s	 |||       rt        j
                  S t        d | |fD              rO |d      }t        j                  |i}|t        j                  i}| j                  |      j                         }|j                  |      j                         }	t        |	      }
t        |	j                               D ]:  }||v s||xx   |	j                  |      z  cc<   ||   r*|j                  |       < t        |	      |
k7  rvt        |j                         D cg c]
  \  }}||z   c}} j                  |      } t        |	j                         D cg c]
  \  }}||z   c}} j                  |      }| |z  } ||      }|j                   r|S |S c c}}w c c}}w )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   )r+  c                     | j                   r=|j                  r1| j                  d      |j                         j                  d      k(  S y)Nr   F)r   is_comparable__add__evalf)rB  r   s     r%   checkz#Mul._combine_inverse.<locals>.check  s8    zzaoo yy|qwwy'8'8';;;r$   c              3   P   K   | ]  }|j                   xs |j                     y wrC   )r   r   rF   r   s     r%   rG   z'Mul._combine_inverse.<locals>.<genexpr>  s!     8Zqxx#188#Z   $&I)sympy.simplify.simplifyr  r1  r+  r   r/   r   r   xreplaceas_powers_dictr~   r   keysr0   r4   r_   r    )lhsrhsr  r+  r  re   _ii_r:   rc   blenr   r>  vr   srvs                   r%   rN  zMul._combine_inverse  s    	5!#:55L	 c?eCo55L8c3Z88 c
A//1%BQ__%BR //1AR //1Aq6DAFFHo7bEQUU2Y&ER5b		 &
 1v~QWWY7YTQAqDY78AA"EQWWY7YTQAqDY78AA"EWrlmms++	 87s   G
G
c                     t        t              }| j                  D ]5  }|j                         j	                         D ]  \  }}||xx   |z  cc<    7 |S rC   )r   r4  r+   r  r_   )rJ   re   r  rc   rd   s        r%   r  zMul.as_powers_dict  sN    IID++-3351!	 6  r$   c           	          t        t        | j                  D cg c]  }|j                          c}       \  }} | j                  |  | j                  | fS c c}w rC   )r.   r6  r+   r   r   )rJ   r   numersdenomss       r%   r   zMul.as_numer_denom  sZ     c		#J	1A$4$4$6	#JKLtyy&!9499f#555 $Ks   Ac                    d }g }d}| j                   D ]Z  }|j                         \  }}|j                  s|dz  }||}n||k7  s|dkD  r| t        j                  fc S |j                  |       \  | j                  | |fS )Nr   r   )r+   r   r"   r   r/   r3   r   )rJ   r   basesr<   r   rc   rd   s          r%   r   zMul.as_base_exp  s    A==?DAq##azbBFQUU{"LLO  tyy% "$$r$   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrC   )_eval_is_polynomialrF   r  symss     r%   rG   z*Mul._eval_is_polynomial.<locals>.<genexpr>  s     Hid4++D1i   allr+   rJ   r  s    `r%   r  zMul._eval_is_polynomial  s    HdiiHHHr$   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrC   )_eval_is_rational_functionr  s     r%   rG   z1Mul._eval_is_rational_function.<locals>.<genexpr>  s     OYT42248Yr  r  r  s    `r%   r  zMul._eval_is_rational_function  s    OTYYOOOr$   c                 H    t        fd| j                  D        d      S )Nc              3   B   K   | ]  }|j                          y wrC   )is_meromorphic)rF   r?  r:   r   s     r%   rG   z+Mul._eval_is_meromorphic.<locals>.<genexpr>  s     K#S//15s   T
quick_exitr   r+   )rJ   r   r:   s    ``r%   _eval_is_meromorphiczMul._eval_is_meromorphic  s    KK'+- 	-r$   c                 @    t        fd| j                  D              S )Nc              3   @   K   | ]  }|j                          y wrC   )_eval_is_algebraic_exprr  s     r%   rG   z.Mul._eval_is_algebraic_expr.<locals>.<genexpr>  s     L)$4//5)r  r  r  s    `r%   r  zMul._eval_is_algebraic_expr  s    L$))LLLr$   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wrC   )r"   rE   s     r%   rG   zMul.<lambda>.<locals>.<genexpr>  s      5-"+Q)rH   r  rJ   s    r%   r   zMul.<lambda>  s     5-"&))5- )-r$   c                     t        d | j                  D              }|du r:t        d | j                  D              rt        d | j                  D              ry y|S )Nc              3   4   K   | ]  }|j                     y wrC   )
is_complexrE   s     r%   rG   z'Mul._eval_is_complex.<locals>.<genexpr>  s     <)QALL)rH   Fc              3   4   K   | ]  }|j                     y wrC   )is_infiniterE   s     r%   rG   z'Mul._eval_is_complex.<locals>.<genexpr>  s     4)Q1==)rH   c              3   8   K   | ]  }|j                   d u  ywrx   r   rE   s     r%   rG   z'Mul._eval_is_complex.<locals>.<genexpr>  s     Ay!qyy-y   )r   r+   r   )rJ   comps     r%   _eval_is_complexzMul._eval_is_complex  sL    <$))<<5=4$))44AtyyAAr$   c                     dx}}| j                   D ]^  }|j                  r	|dur yd}|j                  r	|dur yd}-|du r|j                  |dur yd }|du sJ|j                  W|dur yd }` ||fS )NF)NNT)r+   r   r  )rJ   	seen_zeroseen_infiniter:   s       r%   _eval_is_zero_infinite_helperz!Mul._eval_is_zero_infinite_helper  s    X %*)	MAyy -% 	E)% $%!))*;$E1) $I E)amm.C -)$(M# & -''r$   c                 F    | j                         \  }}|du ry|du r|du ryy NFTr  rJ   r  r  s      r%   _eval_is_zerozMul._eval_is_zeroA  s7     $(#E#E#G 	=$=E#9r$   c                 F    | j                         \  }}|du r|du ry|du ryy )NTFr  r  s      r%   _eval_is_infinitezMul._eval_is_infiniteM  s7     $(#E#E#G 	=D Y%%7e#r$   c                     t        d | j                  D        d      }|r|S |du rt        d | j                  D              ryy y )Nc              3   4   K   | ]  }|j                     y wrC   )is_rationalrE   s     r%   rG   z(Mul._eval_is_rational.<locals>.<genexpr>]  s     ;A!--rH   Tr  Fc              3   8   K   | ]  }|j                   d u   ywrx   r  rE   s     r%   rG   z(Mul._eval_is_rational.<locals>.<genexpr>b       9y!199%yr  r   r+   r  rJ   r   s     r%   _eval_is_rationalzMul._eval_is_rational\  sF    ;;MH%Z9tyy99 : r$   c                     t        d | j                  D        d      }|r|S |du rt        d | j                  D              ryy y )Nc              3   4   K   | ]  }|j                     y wrC   )is_algebraicrE   s     r%   rG   z)Mul._eval_is_algebraic.<locals>.<genexpr>f  s     <)Q!..)rH   Tr  Fc              3   8   K   | ]  }|j                   d u   ywrx   r  rE   s     r%   rG   z)Mul._eval_is_algebraic.<locals>.<genexpr>k  r  r  r  r  s     r%   _eval_is_algebraiczMul._eval_is_algebraice  sF    <$))<NH%Z9tyy99 : r$   c                    | j                         }|du ryg }g }d}| j                  D ]W  }d}|j                  r.t        |      t        j
                  us.|j                  |       @|j                  rd|j                         \  }}t        |      t        j
                  ur|j                  |       |t        j
                  us|j                  |       |j                  r|j                         \  }	}
|	j                  r|
j                  sdx}}|
j                  r?|j                  |t        j                  u rdnt        |t        j                               6|s|
j                  rJ |
j                   rJ  y  y  y  |s|syd }d }d }ddlm |s|rt'        fd	|D              ry|ry  ||      r	 ||      ry ||      r|dgk(  ry ||      r! ||      rt)        |d
didz
  j                  ryt+        |      dk(  rq|d   }|j,                  r`|j.                  rTt1        |D cg c]!  }|j.                  r|j                         d   # c} t3        |j4                        z
  j6                  ryt+        |      dk(  rt|d   }|j,                  rb|j.                  rUt1        |D cg c]!  }|j.                  r|j                         d   # c} t3        |j4                        z
  j                  ryy y y y c c}w c c}w )NFTrX   c                 &    t        d | D              S )Nc              3   4   K   | ]  }|j                     y wrC   )is_oddr  s     r%   rG   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>  s     3AqxxrH   r  r   s    r%   r   z&Mul._eval_is_integer.<locals>.<lambda>  s    3333r$   c                 &    t        d | D              S )Nc              3   4   K   | ]  }|j                     y wrC   is_evenr  s     r%   rG   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>       51a		1rH   r  r  s    r%   r   z&Mul._eval_is_integer.<locals>.<lambda>      C5155r$   c                 &    t        d | D              S )Nc              3   4   K   | ]  }|j                     y wrC   r  r  s     r%   rG   z9Mul._eval_is_integer.<locals>.<lambda>.<locals>.<genexpr>  r  rH   )r   r  s    r%   r   z&Mul._eval_is_integer.<locals>.<lambda>  r  r$   r   )is_gtc              3   L   K   | ]  } |t         j                          y wrC   )r   r/   )rF   _r  s     r%   rG   z'Mul._eval_is_integer.<locals>.<genexpr>  s      37)5Aa   !$rZ   r   )r  r+   r   r   r   r/   r3   r   r   r   r   r   r   r   rS   r   r   
relationalr  r  r4   r~   r   r  r`   r   r   is_nonnegative)rJ   r  
numeratorsdenominatorsunknownr:   hitr   re   rc   rd   alloddallevenanyevenr   r  s                  @r%   _eval_is_integerzMul._eval_is_integerq  s   ,,.%
AC||q6&%%a('')1q6&%%a(AEE> ''*}}1||1<<$((C'== ''Q!&&[Aq}}-/ }},, yy(= 9 < G355%ls 37)537 07JGL$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   1&K?0&Lc                 z    t        d | j                  D              }|xr t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wrC   )is_polarrF   r?  s     r%   rG   z%Mul._eval_is_polar.<locals>.<genexpr>  s     :		rH   c              3   P   K   | ]  }|j                   xs |j                     y wrC   )r  r   r  s     r%   rG   z%Mul._eval_is_polar.<locals>.<genexpr>  s!     E9C//9r  )r   r+   r  )rJ   	has_polars     r%   _eval_is_polarzMul._eval_is_polar  s7    :		::	 FE499EE	Fr$   c                 $    | j                  d      S NT)_eval_real_imagr  s    r%   _eval_is_extended_realzMul._eval_is_extended_real  s    ##D))r$   c                    d}d }| j                   D ]  }|j                  xs |j                  du r|j                  du r y|j                  r| }?|j                  r;|rN|j
                  }|s|du r|}c|sft        d | j                   D              r y y |j                  du r|r y |}|j                  du r|r y |} y  |r&|j                  du r|r|S |j                  du r|s|S y y |du r|S |r|S y )NFc              3   4   K   | ]  }|j                     y wrC   ry   rE   s     r%   rG   z&Mul._eval_real_imag.<locals>.<genexpr>  s     >Iqq{{IrH   T)r+   r  r  r   r   r   r  )rJ   realzerot_not_re_imri   zs         r%   r
  z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                 ^    t        d | j                  D              r| j                  d      S y )Nc              3   T   K   | ]   }|j                   d u xr |j                   " ywrx   )r   rz   rE   s     r%   rG   z)Mul._eval_is_imaginary.<locals>.<genexpr>  s&     E9aqyyE!1akk19s   &(F)r  r+   r
  r  s    r%   _eval_is_imaginaryzMul._eval_is_imaginary  s+    E499EE''.. Fr$   c                 $    | j                  d      S r	  _eval_herm_antihermr  s    r%   _eval_is_hermitianzMul._eval_is_hermitian  s    ''--r$   c                 $    | j                  d      S NFr  r  s    r%   _eval_is_antihermitianzMul._eval_is_antihermitian  s    ''..r$   c                     | j                   D ]:  }|j                  |j                   y |j                  r*|j                  r| }: y  |dur|S | j                         }|ry|du r|S y r  )r+   is_hermitianis_antihermitianr  )rJ   hermri   r   s       r%   r  zMul._eval_herm_antiherm  sz    A~~%););)C~~##x  uK$$&K r$   c                     | j                   D ]P  }|j                  }|r<t        | j                         }|j                  |       t	        d |D              r y y |P y  t	        d | j                   D              ryy )Nc              3   f   K   | ])  }|j                   xr t        |j                        d u  + yw)TN)r  r   r   rF   r   s     r%   rG   z*Mul._eval_is_irrational.<locals>.<genexpr>  s*     XQWA>)AII*>4GQWs   /1Tc              3   4   K   | ]  }|j                     y wrC   )is_realr"  s     r%   rG   z*Mul._eval_is_irrational.<locals>.<genexpr>  s     ,)Qqyy)rH   F)r+   is_irrationalr.   remover  )rJ   ri   r:   otherss       r%   _eval_is_irrationalzMul._eval_is_irrational  sn    AAdiia XQWXXy  ,$)),, -r$   c                 $    | j                  d      S )a  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_positivezMul._eval_is_extended_positive  s      !!!$$r$   c                    dx}}| j                   D ]  }|j                  r|j                  r| } |j                  r t	        d | j                   D              r y y |j
                  r| }d}^|j                  rd}m|j                  du r
| }|r y d}|j                  du r|r y d} y  |dk(  r	|du r|du ry|dk  ryy )NFc              3   4   K   | ]  }|j                     y wrC   ry   rE   s     r%   rG   z$Mul._eval_pos_neg.<locals>.<genexpr>7  s     6Iqq{{IrH   Tr   r   )	r+   rp   rM   r   r  is_extended_nonpositiveis_extended_nonnegativer   r   )rJ   r   saw_NONsaw_NOTri   s        r%   r+  zMul._eval_pos_neg/  s    !!'A%%''u6DII66 **u** %'u%'7 8 19E)g.>!8 r$   c                 $    | j                  d      S rn   r*  r  s    r%   _eval_is_extended_negativezMul._eval_is_extended_negativeR  s    !!"%%r$   c                 6   | j                         }|dur|S ddlm}  ||       \  }}|j                  rt|j                  rht        t        j                  |      D cg c]!  }|j                  r|j                         d   # c} t        |j                        z
  j                  ryy d\  }}| j                  D ]X  }t        |      t        j                  u r|j                  r y|du rn%|dk7  r||z   j                   rd}n|j                  d }|}Z |S c c}w )NTr   r  r   F)Tr   )r   r  r  r   r  r`   r4   r   r   r   r   r   r+   r   r   r/   r  )	rJ   r   r  r   re   r   r   accri   s	            r%   _eval_is_oddzMul._eval_is_oddU  s   **,
T!3~1<<AII MM!$3$ ./()		 mmoa($3 46>qssmD!k" 3A1vyyEzsQw.."C  %3s   &Dc                 2   ddl m}  ||       \  }}|j                  ru|j                  rht	        t
        j                  |      D cg c]!  }|j                  r|j                         d   # c} t        |j                        z
  j                  ryy y y c c}w )Nr   r  r   F)r  r  r   r  r`   r4   r   r   r   r   r  )rJ   r  r   re   r   s        r%   _eval_is_evenzMul._eval_is_evens  s    3~1<<AII MM!$3$ ./()		 mmoa($3 46>qssmD$n% %	 &<3s   &Bc                     d}| j                   D ]1  }|j                  r|j                  s y|dz
  j                  s-|dz  }3 |dkD  ryy)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   )rJ   number_of_argsr?  s      r%   _eval_is_compositezMul._eval_is_composite  sP     99CNNsA""!#	  A r$   c           	      <  ()*+, ddl m, ddlm} ddlm+ ddlm} |j                  sy |j                  d   j                  rR|j                  d   dk  r@| j                  d   j                  r'| j                  d   dk  r| j                  | |       S y d ((+fd}(fd}d	 }d } ||       \  }	}
| }|
t        j                  urJ|	j                  ||      |
j                  ||      z  }|j                  s|j                  ||      S || k7  r|}|j                  d   }|j                  d   }d }|j                  r#|j                  r||k7  r |j                  |      }n|j                  r|S  ||      \  )} ||      \  *}|rf|j                  rZt!        |      d
k7  rLt         |t!        |      |            })j#                  |       |)v r)|xx   |z  cc<   n|)|<   |||z  z  }nd
}d}t%        |      t%        |      kD  rd}nt%        *      t%        )      kD  rd}nt|D ch c]  }|d   	 c}j'                  |D ch c]  }|d   	 c}      rd}n>t)        *      j'                  t)        )            rd}nt+        )*,fd*D              rd}|s|S *sd }nKg }*j-                         D ]+  \  }})|   }|j/                   |||             |d   r)|c S  t1        |      }|s(d }t3        t%        |            D ]  } |||    ||<    nRd}t%        |      }|xs t        j4                  }g }d}|r||z   t%        |      k  rd}g }t3        |      D ]  }|||z      d   ||   d   k7  r nx|dk(  r(|j/                   ||||z      d
   ||   d
                nX||d
z
  k(  r(|j/                   ||||z      d
   ||   d
                n(|||z      d
   ||   d
   k7  r n|j/                  d
       |d
z  } t1        |      } | r|d
k(  r@|rt1        ||       } t7        ||        |||   d   ||   d
   | |d   d
   z  z
        z  ||<   nd
}  |||   d   ||   d
   | |d   d
   z  z
        }!|}"||z   d
z
  }#||#   d   ||#   d
   | |d   d
   z  z
  f}$|$d
   r4||z   t%        |      k  r|!|"z  |$g||||z    n! ||$ }$|!|"z  |$z  g||||z    n|!|"z  g||||z    || z  }|| z  }d}|s|j/                  |       |d
z  }|r||z   t%        |      k  r|s|S |j9                  t3        |t%        |                   |D ]  } |||    j;                  ||      ||<    ||}%n||}%nt1        ||      }%g }&)D ]X  }|*v r')|   *|   |%z  z
  }'|&j/                   |||'             .|&j/                   ||j;                  ||      )|                Z |r|st7        ||      g|&z   }&| |j<                  |& z   |j<                  | z  S c c}w c c}w )Nr   r   )multiplicity)	powdenestr  c                     ddl m} | j                  st        | |      r| j	                         S | t
        j                  fS )Nr   )r`  )&sympy.functions.elementary.exponentialr`  r   rv   r   r   r/   )r:   r`  s     r%   base_expz Mul._eval_subs.<locals>.base_exp  s1     Cxx:a-}}&aee8Or$   c                 N   t        t              g }}t        j                  |       D ]x  } 	|      } |      \  }}|t        j
                  ur$|j                         \  }}t        |||z        }|}|j                  r||xx   |z  cc<   f|j                  ||g       z ||fS )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   r4  r4   r   r   r/   rQ   r   r"   r3   )
eqr;   r<   r:   rc   rd   r9   r  rB  r?  s
           r%   breakupzMul._eval_subs.<locals>.breakup  s     #3'Q]]2&aL!!AAEE>nn.GRAqtAA##aDAIDIIq!f% ' r7Nr$   c                 8     |       \  } }t        | ||z        S )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   )rc   r9   rd   rB  s      r%   rejoinzMul._eval_subs.<locals>.rejoin  s"     a[FQq!B$<r$   c                     |j                   | j                   z  r| j                   |j                   z  st        | |z        S y)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   r4  )r:   rc   s     r%   ndivzMul._eval_subs.<locals>.ndiv  s1    
 339ACC!##I1Q3xr$   r   TFc              3   L   K   | ]  } |          |         k7    y wrC   r#   )rF   rc   r;   old_cr   s     r%   rG   z!Mul._eval_subs.<locals>.<genexpr>  s'     =u!adtE!H~-ur  ro   )r   r   sympy.ntheory.factor_r>  sympy.simplify.powsimpr?  r  r  r   r+   r    _subsr   r/   r   extract_multiplicativelyr   r0   r~   
differencesetr   r_   r3   minr   r   r   r2   rG  r   )-rJ   rX  newr>  r  rE  rH  rJ  r   r   re   self2co_selfco_oldco_xmulr<   old_ncr  co_residualokr   cdidratrc   old_ec_encdidtakelimitfailedr  r   ndorB  midirr   domargsrd   rB  r;   rL  r?  r   s-                                           @@@@@r%   
_eval_subszMul._eval_subs  s   =643zz 88A;  SXXa[1_yy|%%99Q<!#::sdSD11		*	 	 ~1AEE>GGC%aggc3&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Z""3q6*B=u==BIDC#kkm
Ed

4U+,2w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//S9BqE  
 <B]BUD!BAEz aD58B;&VAq\*VAFF3$4ad;<   d^$u,E:5::u--jejj"o==U $/As   )XXc                 F    ddl m} ddlm} ddlm} d }g }		 | j                  D ]@  }
|
j                  |      \  }}|j                  |      s|	j                  |
|f       <t         t        d |	D              }g }|	D ]f  \  }
} |||z
  |j                  r|ndz         }|
j                  ||||      }|j                         }|||k  r|||z
  z  }|j                  |       h 	 t&        j(                  }|D cg c]  }t3        j4                  |       }}t7        | D ]O  }|D cg c]  } |||       }}t9        | \  }}t        |      }||z
  j:                  s?|t=        | ||z  z  z  }Q  fd | j?                  |      r=ddl m!} ddl"m#} 	   | |      |k\  s || |       |||      k7  r| |||z  |      z  }|S || k7  rc| |z
  jI                  |d      t&        j(                  k(  r.|dkD  r)| jK                  |||      }|t&        j(                  k(  r|S | |||z  |      z  }|S # t        t        t         |f$ r t#        t        d	 |	D                    }|j$                  rt&        j(                  }| j                  D 
cg c]   }
|
j                  | |||z
        ||      " nc c}
w }}
dd
lm}  | | j.                  | j1                         dd      }|j                  |      r| |||z  |      z  }|cY S w xY wc c}w c c}w # |$ r Y Ww xY w)Nr   )	PoleErrorr   )ceiling)Orderc                     | j                  |      }|d   j                  |      r	 | j                  |      }|S |S # t        $ r | t        j
                  fcY S w xY wrP   )as_coeff_exponentr   leadterm
ValueErrorr   r   )r  r   lts      r%   	coeff_expz$Mul._eval_nseries.<locals>.coeff_exp  s^    ''*B!uyy|(q)B I2I " (<'(s   < AAc              3   F   K   | ]  }|d    j                   s|d      ywr   Nr   rF   ri   s     r%   rG   z$Mul._eval_nseries.<locals>.<genexpr>  s     :4a1Q4>>QqT4   !
!)r   logxcdirc              3   F   K   | ]  }|d    j                   s|d      ywru  rv  rw  s     r%   rG   z$Mul._eval_nseries.<locals>.<genexpr>  s     B4a1Q4>>QqT4rx  )powsimpr`  T)combiner   c           	         | u rt         j                  S | j                  rt         j                  S | j                  rt        fd| j                  D              S | j                  r't        | j                  D cg c]  } |       c} S | j                  r  | j                        | j                  z  S t         j                  S c c}w )Nc              3   0   K   | ]  } |        y wrC   r#   )rF   r:   
max_degreer   s     r%   rG   z8Mul._eval_nseries.<locals>.max_degree.<locals>.<genexpr>  s     <V:a+Vs   )r   r/   is_Atomr   r   maxr+   r   r`   r   ra  r`  )rd   r   r:   r  s    ` r%   r  z%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ry  rz  )&r  rk  #sympy.functions.elementary.integersrl  sympy.series.orderrm  r+   rp  r   r3   rq  r:  r   nseriesgetnNotImplementedError	TypeErrorr   r  r   r   rN  r|  r   r   r`   r   r   r6  r   r4   is_polynomialsympy.polys.polyerrorsr  sympy.polys.polytoolsr  rG  _eval_as_leading_term)!rJ   r   r   ry  rz  rk  rl  rm  rs  ordsri   r   r`  n0facsr   n1r%  nsr|  resr  ords2facr  ords3coeffspowerspowerr  r  rr  r  s!                                   @r%   _eval_nserieszMul._eval_nseries  s   '?,	 	YYZZ]
syy|KKC)$$  :4::BD1QVAKKqQ?@IIa2DtI<VVX>BwR"WA . ff59:T6v&T:E?C478CDYtQ'CE8 %[NFFKE	&&sF|QX.. #	 a >4dA&!+vdA&a./P5Aq>)C 
$;s
  A&!&&0QU//4/H<J5Aq>!C
m /IF 	 B4BBCB  VVQUQZQZ[QZAAIIa71R4=t$IGQZ[D[6)$))T*113UNCwwu~uQT1~%J	 ; 92 # s>   CH2 =L*L.L 2AL
%J21AL
	L
L L c           
      ~     | j                   | j                  D cg c]  }|j                  |||       c} S c c}w )Nr  )r   r+   as_leading_term)rJ   r   ry  rz  ri   s        r%   r  zMul._eval_as_leading_term  s;    tyytyyYy!1,,QT,EyYZZYs   :c                 v     | j                   | j                  D cg c]  }|j                          c} S c c}w rC   )r   r+   r   rJ   ri   s     r%   _eval_conjugatezMul._eval_conjugate  s/    tyy$))<)Q1;;=)<==<s   6c                      | j                   | j                  d d d   D cg c]  }|j                          c} S c c}w rn   )r   r+   	transposer  s     r%   _eval_transposezMul._eval_transpose  s7    tyy$))DbD/B/Q1;;=/BCCB   <c                      | j                   | j                  d d d   D cg c]  }|j                          c} S c c}w rn   )r   r+   adjointr  s     r%   _eval_adjointzMul._eval_adjoint  s7    tyy		$B$@1199;@AA@r  c                     t         j                  }g }| j                  D ]A  }|j                  ||      \  }}||z  }|t         j                  us1|j	                  |       C | | j
                  | fS )aU  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   r/   r+   as_content_primitiver3   r   )rJ   r  r  coefr+   r:   r;   r   s           r%   r  zMul.as_content_primitive  sp     uuA))')GDAqAID~A	  YTYY%%%r$   c                 ^    | j                         \  }}|j                  fd       ||z   S )a  Transform 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                 (    | j                        S )N)order)sort_key)r  r  s    r%   r   z(Mul.as_ordered_factors.<locals>.<lambda>'  s    DMMM$>r$   r'   )r1   r)   )rJ   r  cpartncparts    `  r%   as_ordered_factorszMul.as_ordered_factors  s-     v

>
?v~r$   c                 4    t        | j                               S rC   )r   r  r  s    r%   _sorted_argszMul._sorted_args*  s    T,,.//r$   )F)Tr  rC   )r   rP   )FT)Qr   r   r   __doc__	__slots__tTupler   __annotations__r   
_args_typer   rI   propertyrD   rN   rT   classmethodr   r   r   r   r   r   r   rQ   r]   r   staticmethodr  r  r&  r3  rL  rR  rO  rV  rW  rg  rh  rz  r{  rN  r  r   r   r  r  r  r  _eval_is_commutativer  r  r  r  r  r  r   r  r  r
  r  r  r  r  r(  r,  r+  r4  r7  r9  r<  ri  r  r  r  r  r  r  r  r  __classcell__)rC  s   @r%   r4   r4   [   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$   r4   mulc                 8    t        t        j                  | |      S )a  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%   r;  r;  1  s    . (,,5))r$   c           
         | j                   s|j                   r| |} }n| |z  S |t        j                  u r| S | t        j                  u r|S | t        j                  u r|s| S |j                  r|s| j
                  r| j                  dk7  r|j                  D cg c]  }|j                          }}|D cg c]  \  }}t        ||       |f }}}t        d |D              rCt        j                  |D cg c]$  }t        j                  |d   dk(  r|dd n|      & c}      S t        | |d      S |j                  rrt        |j                        }|d   j                   r'|dxx   | z  cc<   |d   dk(  r$|j!                  d       n|j#                  d|        t        j                  |      S | |z  }|j                   r#|j                   st        j                  | |f      }|S c c}w c c}}w c c}w )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   :   K   | ]  \  }}|j                     y wrC   )r   )rF   r;   r  s      r%   rG   z_keep_coeff.<locals>.<genexpr>u  s     1DDAq1<<Dr{   r   NFrY   )r    r   r/   rS   r   r   r   r+   r]   r   r   r`   r5   r4   r   r.   r0   r6   )	r   factorsr  r   r   r+   r;   r   rh  s	            r%   r   r   K  s   6 ??"GUG= !%%~	!--	x	**uww!|.5ll;lANN$lD;;?@441a[E*A.4D@1D11~~8<'>8<1 (+~~qTQYAabEA(/8<'> ? ?5'E22	W\\"8!HHQx1}		!LLE"~~e$$'M;;w00w/0A' <@'>s   G)7G.7)G4c                      d }t        | |      S )Nc                     | j                   rN| j                         \  }}|j                  r/|j                  r#t	        |j
                  D cg c]  }||z  	 c} S | S c c}w rC   )r   r]   r    r   _unevaluated_Addr+   )rd   r;   r   ris       r%   rg  zexpand_2arg.<locals>.do  sS    88>>#DAq{{qxx')@2!B$)@AA *As   Ar   )rd   rg  s     r%   expand_2argr    s     Qr$   )r   rG  )r`   r  )r   )TF)4typingr   r  collectionsr   	functoolsr   	itertoolsr   r  r   basicr	   r
   	singletonr   
operationsr   r   cacher   intfuncr   r   logicr   r   r  r   
parametersr   rD   r   	traversalr   sympy.utilities.iterablesr   r   r,   r=   r4   r  r;  r   r  r   r   r  r   addr`   r  r#   r$   r%   <module>r     s    " #     '  2  . *  )     * !
3#lQ0$ Q0f> *4;z   & &r$   