Ë
    O/æjÐ2 ã                   ó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© ó    úQ/root/repos/pocs/video-evals/.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   € à‡I�I”-€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Ù
Ø�H‰H‹JˆØ�8Š8Ø—J‘J“L‰EˆAˆrØ�K‰K˜ŒNÙØ—‘œcŸn™n¨RÓ0Õ1Ø�[Š[Ø�!‰G‰Bà�N‰N˜1Ôò ô ˆ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   è ø€ Ò/ �Q—V•VÑ/ùó   ‚)r+   Ú_kind_dispatcher)ÚselfÚ	arg_kindss     r%   rD   zMul.kindª   s#   € á/ T§Y¡YÔ/ˆ	Ø$ˆ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   € Ø�T�EŠ?ØØ�I‰I�a‰LˆØ�{‰{Ò5˜q×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Ø”A—E‘E‰>Ø�A‰w× Ò Ü˜D“z�ØœŸ™Ñ%Ø# A™w˜h�D˜’Gà˜“G˜q‘L”Gà�t˜d‘{�Ø�‰˜t T×%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Ø—^‘^Ó%�Ø×#Ñ# A rÓ*×5Ñ5Ø�q‘E˜2óß%™v b¨¡e�}ð-ð !Ÿ™Ó(ò %‘��1ØŸg™g›iò %‘F�B˜Ü ˜H�A�b’Eñ%ð%ð ˆLØ Ÿ™Ó(ò F‘��1Ø×#Ñ#¸!¿'¹'»)×$D±$°!°Q a¨¨1©¢XÓ$DÕEðFàÐùó %Es   ÃC"c              3   ó:   •K  — | ]  }|‰j                   v –— Œ y ­wrC   r*   )rF   Úinftyrc   s     €r%   rG   zMul.flatten.<locals>.<genexpr>  s!   øè ø€ ò 6;Ø!ð 7<¸q¿v¹v´oñ 6;ù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’  sS   € Ø�
Øò )�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   øè ø€ Ò>°”:˜a ×,Ñ>ùs   ƒc              3   ó:   K  — | ]  }|j                   d k(  –— Œ y­w©FN©Ú	is_finite)rF   r;   s     r%   rG   zMul.flatten.<locals>.<genexpr>²  s   è ø€ Ò8¨A�1—;‘; %Õ'Ñ8ùó   ‚)=Ú!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ØˆÜˆs‹8�qŠ=Ø‰DˆAˆqØ�}Š}Ø˜!���1Ø˜!�f�ØœAŸE™E‘>Ð!�>Ø�}Š} Q§Y¢YØ—~‘~Ó'‘��1Ø—8’8Ø¤§¡‘~à˜q™S˜Ø¤§¡™;Ø"#™Cá"% a¨¡c¨1°uÔ"=˜CØ!˜U B¨˜_™Ü*×5Ò5¸!×:JÒ:JÜ"À!Ç&Á&Ö$I¸B¤[°°BÕ%7Ò$IÐJ˜Ø"˜V R¨Ð-˜ÙØ�	ð ˆØˆàˆä—‘ˆð ˆð ˆô —‘ˆàˆð ˆð ó u	0ˆAà�zŠzØ#$×#6Ñ#6°}Ó#EÑ ��=ð �xŠxØ×#Ò#Ø—J‘J˜qŸv™vÕ&ð ŸV™Vò -˜Ø×+Ò+ØŸJ™J q�Mà"ŸM™M¨!Õ,ð	-ð —J‘JœyÔ)àð —’ØœŸ™‘: ¬!×*;Ñ*;Ñ!;ÀÇ	Â	äŸE™E˜7 B¨Ð,Ò,Ø—_’_¬
°5¸+Ô(FØ˜Q‘J�EØ¤§¡‘~ä !§¡˜w¨¨DÐ0Ò0Ùä˜A˜{Ô+ØŸ	™	 %Ó(�Ùà”a×'Ñ'Ñ'ÙäŸE™E˜7 B¨Ð,Ò,Ü×)Ñ)�Ùà”a—o‘oÑ%ØœŸ™‘�Ùà×!Ó!ð —}‘}“‘��1ð —8’8Ø—{’{ð
 Ÿ=š=Ø Ÿ|š|Ø %¬¨Q°«Ñ 2 Ù (Ø!"§¢Ø #§
¡
¬3¨q°!«9Ô 5Ù (Ø!"§¢Ø %¨¡
 Ø%& B Ø ¬¯©™~Ø (× 3Ñ 3°A°rÓ :× AÑ AÀ!Ô DÙ$ØŸ]š]¨a¯lªlØ#ŸN™N¨A¨q¨6Ô2Ù$à—‘  A Ö'ð
 œIÑ%Ø—M‘M !Ô$ó ØŸ
™
 1›�AÙ"ØŸ™ qÔ)Ø ð !Ÿ™›�BØŸ^™^Ó-‘F�B˜ØŸ]™]›_‘F�B˜Ø  2™g�Gð
 ˜R’x¨¯ªØ  G™m˜ð ×-Ò-ØŸJ™J sœOØ$à"ŸM™M¨!¨SÕ1ð  Ÿ™¨¨A wÔ/ô7 ðuu	0òH	 ñ ˜8Ó$ˆñ ˜'Ó"ˆô0 �q“ó $	ˆAØˆLØˆGØ ó ,‘��1Ø—9’9àŸš A§H¢H´#ó 6;Ü&'×&7Ñ&7¼¿¹Ü&'×&8Ñ&8ð&:ô6;ô 3;ô !"§¡˜w¨¨DÐ0Ô0ØØœŸ™‘:Ø—{’{Ø ™
˜Ø Ø�AØœAŸE™E‘>Ü˜A˜q›	�Að —x’x¨¯ªØ˜Ø Ÿ}™}›™˜˜1Ø š7Ø&*˜GØ—‘˜aÔ Ø×#Ñ# Q¨ FÖ+ð1,ñ6 œ3Ø".÷ 0Ù˜!˜Q’Aó 0ó 1Ü47¸Ó4EòFð �Ù" <Ó0’áðI$	ðP ˆàò 	5‰DˆAˆqØ×#Ñ# A rÓ*×1Ñ1°!Õ4ð	5à ×&Ñ&Ó(ò 	&‰DˆAˆqÙ! 1˜gˆL˜ŠOð	&à�‰¨\×-?Ñ-?Ó-A×G¡T Q¨ÂQ”s˜1˜a•yÓGÔHð ˆØ—N‘NÓ$ò 	5‰DˆAˆqØ×Ñœc 1˜g rÓ*×1Ñ1°!Õ4ð	5àð ˆØ—L‘L“Nò 		#‰DˆAˆqÙ�Q�ˆAØ�s‰s�aŠxØœ˜Q ›Ñ"�ØØ�s‰s�Q—S‘SŠyÜ  §¡ a§c¡cÓ*‘��RØœ˜Q ›Ñ$�Ü˜R §¡Ó%�Ø�N‰N˜A˜q˜6Õ"ð		#ð ô œ4Ó ˆØˆØ”#�g“,ÓØ˜Q‘Z‰FˆB�Ø�QŠwØ�Q‘�ØØˆDÜ˜1˜q™5¤# g£,Ó/ò �Ø  ™‘��BØ—F‘F˜2“J�ØœAŸE™E’>ð ˜R™�AØ—s‘s˜a’xØ¤ Q¨£Ñ*™àŸ3™3 §¡š9Ü&,¨Q¯S©S°!·#±#Ó&6™G˜C Ø!¤S¨¨C£[Ñ0˜EÜ (¨¨Q¯S©SÓ 1˜AØŸ™ Q¨ FÔ+à"$ Q¡$¨ �G˜A‘Jà˜A™�BØœQŸU™U’{Ùð)ð* œŸ™‰Ü˜"˜b“k�Ø—=’=Ø˜S‘L‘Eô  #Ÿ}™}¨SÓ1ò 0˜ØŸ=š=Ø! S™L™Eà#&§:¢:Ð- :Ø%(§X¡X™F˜B Ø  ™HŸO™O¨BÕ/ð0ð �N‰N˜4Ô Ø�‰FˆAðU ”#�g“,ÔðZ —J‘J“Lò 	‰DˆAˆqÙ˜1�gˆD�ŠGð	ñ à×(Ñ(Ó*‰DˆAˆqä˜!˜Q“<‰DˆAˆqØ�1ŠuØ˜�à�AŠvØ—‘œaŸo™oÕ.Ùô !  A›�Ø ŸJ™J›Lò M‘D�A�qØ˜E“z a§m£mØ#$ "˜˜Q™ÙðMð —M‘M¤#¤a§m¡m°UÀUÔ"KÔLð 	�‰¨T¯Z©Z«\×:¡T Q¨”s˜1˜a•yÓ:Ô;ð ”Q—Z‘Z¤×!3Ñ!3Ð4Ñ4ò	.ñ "0°¸Ó!:ÑˆF�JÙ"0°¸*Ó"EÑˆG�ZØ�ZÑˆEð ”A×%Ñ%Ñ%ð "(ö Q˜A´	¸!¿)¹)Ô0DØ01×0BÑ0BÐ0Nò ð QˆFð Qà")ö S˜Q´)¸A¿I¹IÔ2FØ23×2DÑ2DÐ2Pò ð SˆGñ Sð �]Š]ô Ó>°gÔ>Ô>Ø�w ¨Ð6Ð6ÜÑ8°Ô8Ô8ÜŸ™�w  MÐ1Ð1Ø�7˜B Ð-Ð-ð ˆØò 	ˆAØ�{Š{Ø˜‘
‘à—‘˜A•ð		ð
 ˆô 	�Ôð œŸ™ÑØ�M‰M˜!˜UÔ#ô ×(Ò(±¼SÀ»[ÈAÒ=MØ�q‘	×#Ò#¨¨q©	×(;Ò(;ÀÀqÁ	×@PÒ@Pà˜1‘IˆEÜ¨V°A©Y¯^©^Ö<¨˜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
                  r•t        |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Ï  sF  € ð —M‘M¨%�MÓ0‰	ˆˆrà�<Š<Ü¸EÖB°qœ˜Q ¨EÖ2ÒBÐCÜ”C—N‘N 2Ó&¨°EÔ:ñ;ð ;à�=Š=˜QŸS™S AšXØ× Ò Ø×%Ñ%Ó'¨Ñ*�Ø—=’=Ü˜q ™s›8×2Ñ2Ó4‘D�A�qÜ*¨1¨aÓ0‘D�A�qÙÜ.¨q°!Ó4™˜˜1ÙÝQÜ '¨£
¨1¡˜AÜ#3°A°q·s±s±F¸QÁÀaÃÌÏÉÑAXÑ=XÐ[\×[^Ñ[^Ñ<^Ó#_Ð_ä��a %Ô(ˆà�=Š=˜AŸJšJØ×,Ñ,Ó.Ð.àˆùò) 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Ø”—‘ÑØ�xŠxÜ×)Ñ)¨!¨TÓ2Ð2‘à—}‘} TÓ*�ØÐ#Ø�AØ�R‘ä×$Ñ$ T¨4Ó0ˆBØ�<Š<Ø—9‘9“;ÐØˆ	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Ñˆ�ØœAŸO™OÑ+ô !Ð!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[   € ð* �y‰yˆäˆt‹9˜Š>Ü—5‘5˜$�;ÐÜ�‹Y˜!Š^ØˆKð ˜‘7Ð-˜D×-Ñ-¨t°A°B¨xÐ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   ø€ ¨u¨q¯u©u°d¨|€ 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ÔI‰FˆB�Ø$�4×$Ñ$ bÐ)¬5°«9Ð4Ð4Ø�y‰yˆØ�‰7×ÒÙ˜t A™w×2Ò2Ø˜A‘w  Q R Ð(Ð(Ø�a‘×-Ò-Ü—}‘}¨¨Q© x k°D¸¸°HÑ&<Ð<Ð<Ü�u‰u�dˆ{Ð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    € ð —i‘i ‘l D§I¡I¨a¨b Mˆtˆà�?Š?Ù˜u×0Ò0Ü�t“9 ’>Ø  $ q¡'˜>Ð)à Ð"3 $×"3Ñ"3°TÐ":Ð:Ð:Ø×+Ò+Ü—}‘}Ð&7 d×&7Ñ&7¸E¸6¸)ÀdÑ:JÐ&LÐLÐLÜ�u‰u�dˆ{Ð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  sM  € ßDÑDØˆØˆØˆÜ—5‘5ˆØ—‘ò 	 ˆAØ—>‘>Ó#‰DˆAˆqØ�yŠyØ—‘˜aÕ Ø—’Ø—‘˜a¤§¡Ñ/Õ0Ø×!Ò!Ù).˜Ÿ™œ°D�ä% eÓ,ò 	(‘D�A�qØ˜E“zØŸ™¡c¨!£f¨a¡iÔ0Ø! !˜HÙð		(ð —x’xØ  A™™àŸ™ Q�à—‘˜Q•ð)	 ð* ˆD�I‰I�uÐˆØ�9‰9�XÓ !Ò#ØÜˆv‹;˜Š?Ù�f—j‘j “mÓ$‰Dô —6‘6ˆDØˆt�y‰y˜6 F™?Ð,ˆØ‘R˜“U‘
˜D¡ A£™Jˆ1ˆØ�qŠ=Ø�AŠvØ—<’<Ø ¤!§&¡&˜>Ð)äŸF™F D¨¡IÐ.Ð.Ø”q—v‘v‰~Ø˜1�v�Ø�E˜!‘G˜T !™VÐ$Ð$Ý(Ù! (°Ô7×DÑDÓF‰ˆˆuØ”1—6‘6‰>Ø�e‘G˜a ™gÑ% q¨¡w°°5±Ñ'8Ð9Ð9à�5˜‘7˜D ™FˆqˆAØ�e‘G˜a ™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—<‘<ÐØˆÜ�‰˜t E Q¨¡T˜{Ó+ˆÜ—‘  Q¨¡T U Ó,ˆà$(×8˜q°%Ò8¨Q”�Q˜•Ð8�Ð8ˆÑ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¨¯­Ñ'Aù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ð ˆá˜˜eŸi™i¨°Ó7Ó8‰ˆˆ1Ø�8Š8à˜Q˜ö!Øð 45·8²8Ð&�A×&Ñ&Ñ/¨Ò/ÀÑBò !‰DˆAˆqà�‰sˆØ�{Š{ØˆKà! 2 u�WˆtˆØ—i‘iò 	/ˆFØ�}Š}Ø—‘˜FÔ#Ø‘à×(Ò(Ø—L‘L Õ(à—K‘K¤ f£Õ.ð	/ñ ØˆKà�D—I‘I˜uÐ%ˆEÙØ—y‘y ¨Ó/�ØŸ	™	×-Ñ-¨dÓ3�Ø�Ø!ò #�DØŸ	™	 %¨Ó.�AØ—x’x¤CÑ'A¸!¿&¹&Ô'AÔ$AÁdØ×.Ñ.Ó0˜Ø—K‘K •Nð	#ô
 ˜D�zÐ!à�ùò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Ž   € ä�D—I‘I‹ˆØˆÜ”s˜4“yÓ!ò 	_ˆAØ�Q‘—‘˜Q“ˆAÚð —‘œVÑ$4°t¸B¸Q°xÀ1À#±~ÈÈQÐQRÉUÈVÈÑ7TÔWX×W\Ñ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Ü˜!˜l¨FÐ3Ô4ô ‘7Ñ3°A°qÓ9Ð9Ý$Ø�y‰yˆÜ�‹IˆÜ�aœ#˜w˜Ô(àˆEÝSÙ=¸aÀÓCò $‘��qÜ¼¸UÀDÓ9I×J©v¨q°#˜#Ÿ(™( A q 6Õ*ÓJÐK�Ø—‘˜Q ™UÕ#ð$ô ˜�;ÐÝ1ÝFÝ@Ù˜ !™¨Ô/ˆØ”C˜“J‘ˆÙ˜!“ˆà”$”s˜9 eÓ,Ó-Ñ-©i¸Ó.>Ñ>Ü´u¸Q¸q¹S³zÖB°!�$�q‘'—,‘,  5¨¡8˜}Õ-ÒBÐCñDà�‰H�M‰M˜1™c ! U›mÐ,Ó-ñ.ð !&Ö&˜1ˆa��AŠYÒ&ð	 ˆñ
 �1ˆz�qŠzÐùó 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   € Ý@Ø�y‰y˜‰|ˆÜ�D—I‘I˜a˜b�MÐ"ˆØ—	‘	˜!˜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‹:˜Š?Ø—n‘n×5Ñ5°d¸EÓBˆGØ˜‘8×#Ñ# G¨YÓ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Ø×,Ñ,¨T°9¸cÓBÐBØ× Ñ ¨×(;Ñ(;Ñ;Øð —-‘-“/‰ˆˆCØ—-‘-“/‰ˆˆCØ%'¨ HÖ-˜q�!’(˜�s‘(Ò-‰ˆˆBô ˜R˜ˆÜ˜R˜ˆà!×)Ñ)¨-¸ÀCÓHˆ	ñ ˜R 2šXØô ×&Ñ& sÓ+ˆÜ×&Ñ& sÓ+ˆä×(Ñ(¨¨c°9Ó=ˆ	àÒ ˜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  sU   € àˆØò 	%ˆCØ�zŠz˜cŸg™g¨škØ—‘ §¡ 
¨S¯W©WÑ 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 )zóNon-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ð ˆàˆØ$Ñˆ�*àˆàœ3˜w›<Ò'¨H´s¸5³zÒ,AØ˜‘?ˆDà�|Š|Ü×)Ñ)¨-¸Ô?ä ×4Ñ4°]ÀEØ5:¸GóEˆNáØ*8Ñ'�
˜KØ—‘˜jÔ)ÙØ!,ò >˜Ø+6°uÑ+=˜	 %Ò(ð>áØàŸ
™
›�Ø',Ñ$�˜*ð% œ3˜w›<Ò'¨H´s¸5³zÓ,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Ñ-‰JˆE�3Ø$)¨:Ð#6ˆJ�xÒ à$.°
Ð#;ˆJ�xÒ r$   c                 ó€  — |\  }}||   }||   }|t        |«      dz
  k\  r|t        |«      dz
  k  ry |j                  r«t        j                  | |||«      }|r�t        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Ñ4°ZÀØ5:¸GóEˆMáô #&×">Ñ">¸zØ?DÀhó#P�à*ò 	(�CØ-7¸©_Ñ*�K Ø+5°hÑ+?Ñ(�J à$+¨K¸	ÀA¹Ð$F�MØ&-¨j¸ÀA¹Ð&F�Oä'*¨?¸MÓ'Jò (™˜˜eØ 5›=Ú#'ñ(ð	(ð '¨
°Q©Ð7Ð8�	àœc %›j¨1™nÒ,Ø×$Ñ$ h°¡l°JÀ±NÐ%CÔDØ  -Ð/Ð/ð/ ð8 œ3˜u›:¨™>Ò)¨j¼3¸w»<È!Ñ;KÒ.KØà ŸL™L¨Ó0ˆMáØ! A™ z°A¡~Ð6Ð7¸ÐFÐFØ˜’Ø! A™ z°A¡~Ð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Ø˜˜c A™gÐ&ˆä! %›j¨1šnŒs�E‰{°%¸±(ˆØ×Ñ Ó%Ð%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˜  s,   € ð ˜‘?ˆØ)ÖD˜¨U°3©Z¸8Ó-C’Ò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   € Ø�zŠz˜aŸošoð —y‘y “| q§w¡w£y×'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    è ø€ Ò8¨ˆq�x‰xÒ#˜1Ÿ8™8Ó#Ñ8ùó   ‚$&Ú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Ý!Ø�#Š:Ü—5‘5ˆLò	ñ ��cŒ?™e C¨œoÜ—5‘5ˆLÜÑ8¨c°3¨ZÔ8Õ8ñ �c“
ˆAÜ—/‘/ 1Ð%ˆBØ”Q—_‘_Ð%ˆBØ—‘˜RÓ ×/Ñ/Ó1ˆAØ—‘˜RÓ ×/Ñ/Ó1ˆAÜ�q“6ˆDÜ˜AŸF™F›H“oò "�Ø˜’7Ø�b“E˜QŸU™U 2›YÑ&“EØ˜R›5ØŸ™˜b�	ð	"ô
 �1‹v˜Š~Ü¨Q¯W©W«Y×7¡T Q¨˜A˜q›DÓ7Ð8×AÑAÀ"ÓE�Ü¨Q¯W©W«Y×7¡T Q¨˜A˜q›DÓ7Ð8×AÑAÀ"ÓE�Ø�‰WˆÙ�r‹lˆØ—m’mˆsÐ+¨Ð+ùó	 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È  sX   € ÜœÓˆØ—I‘Iò 	ˆDØ×+Ñ+Ó-×3Ñ3Ó5ò ‘��1Ø�!“˜‘	”ñð	ð ˆ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Ï  sV   € ô œcÀÇ	Á	Ö#J¸1 A×$4Ñ$4Õ$6Ò#JÐKÓL‰ˆ�Øˆt�y‰y˜&Ð! 9 4§9¡9¨fÐ#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Ø—=‘=“?‰DˆAˆqØ×#Ò#Ø�a‘�ØˆzØ‘Ø�b’˜B šFØœQŸU™U�{Ò"Ø�L‰L˜�Oð	ð ˆt�y‰y˜%Ð  "Ð$Ð$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   øè ø€ ÒH°d�4×+Ñ+¨D×1ÑHùó   ƒ©Úallr+   ©rJ   r®  s    `r%   r¬  zMul._eval_is_polynomialå  s   ø€ ÜÓH¸d¿i¹iÔ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   øè ø€ ÒO¸T�4×2Ñ2°4×8ÑOùr¯  r°  r²  s    `r%   rµ  zMul._eval_is_rational_functionè  s   ø€ ÜÓOÀTÇYÁYÔ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ÑKù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ÑLù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-Øˆ×Õñ5-ù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   è ø€ Ò<¨Q˜AŸL�LÑ<ùrH   Fc              3   ó4   K  — | ]  }|j                   –— Œ y ­wrC   )Úis_infiniterE   s     r%   rG   z'Mul._eval_is_complex.<locals>.<genexpr>ø  s   è ø€ Ò4 Q�1—=•=Ñ4ùrH   c              3   ó8   K  — | ]  }|j                   d u–— Œ y­wrx   ©r€   rE   s     r%   rG   z'Mul._eval_is_complex.<locals>.<genexpr>ù  s   è ø€ ÒA°!�q—y‘y¨Ô-ÑAùó   ‚)r   r+   r’   )rJ   Úcomps     r%   Ú_eval_is_complexzMul._eval_is_complexõ  sL   € ÜÑ<°$·)±)Ô<Ó<ˆØ�5‰=ÜÑ4¨$¯)©)Ô4Ô4ÜÑA°t·y±yÔ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Ø�yŠyØ ¨Ñ-Ù%Ø ‘	Ø—’Ø EÑ)Ù%Ø $‘à Ñ%¨!¯)©)Ð*;Ø$¨EÑ1Ù)Ø $�IØ  EÒ)¨a¯m©mÑ.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  ó   è ø€ Ò9¨!�1—9‘9 Ô%Ñ9ùrÊ  ©r   r+   r±  ©rJ   r    s     r%   Ú_eval_is_rationalzMul._eval_is_rational\  sF   € ÜÑ;°·±Ô;ÈÔMˆÙØˆHØ�%‰ZäÑ9¨t¯y©yÔ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äÑ9¨t¯y©yÔ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¨A˜qŸx�xÑ3ùrH   ©r±  ©rí   s    r%   rï   z&Mul._eval_is_integer.<locals>.<lambda>š  s   € œ3Ñ3°Ô3Ó3€ r$   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>›  ó   è ø€ Ò5¨a §	¥	Ñ5ùrH   ré  rê  s    r%   rï   z&Mul._eval_is_integer.<locals>.<lambda>›  ó   € œCÑ5°1Ô5Ó5€ r$   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Ø$%‘�aœŸ™—ñ37ùó   ƒ!$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Ø�|Š|Ü�q“6¤§¡Ò&Ø×%Ñ% aÕ(Ø—’Ø×'Ñ'Ó)‘��1Ü�q“6¤§¡Ñ&Ø×%Ñ% aÔ(ØœAŸE™E’>Ø ×'Ñ'¨Õ*Ø—’Ø—}‘}“‘��1Ø—|’|¨1¯<ª<Ø$(Ð(�C˜'Ø—=’=Ø ×'Ñ'¨Q´!·&±&©[©Ü˜AœqŸ}™}Ó-ö/áà Ÿ}š}Ð,Ð,à ŸyšyÐ(˜=Ùñ áð9	ñ< ¡GØá3ˆÙ5ˆÙ5ˆå%Ù™l¬só 37Ø)5ô37ô 07àÙØÙ�JÔ¡G¨LÔ$9ØÙ�ZÔ  \°a°SÒ%8ØÙ�ZÔ ¡V¨Lô &Ü˜LÐ9°5Ñ9¸AÑ=ß‘+ðàÜˆ|Ó Ò!Ø˜Q‘ˆAØ�|Š| §	¢	ô Ø"ö1°Ø&'§i¢ið Ÿ-™-›/¨!Ó,ò 1ð 2Ü4<¸Q¿S¹S³MñBç(™.ð)ð  Üˆz‹?˜aÒØ˜1‘ˆAØ�|Š| §	¢	ô Ø$ö3°Ø()¯	ª	ð Ÿ-™-›/¨!Ó,ò 3ð 4Ü6>¸q¿s¹s³mñ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    è ø€ ÒE°C�—‘Ò/ §¡Ó/ÑEùr—  )r’   r+   r±  )rJ   Ú	has_polars     r%   Ú_eval_is_polarzMul._eval_is_polar¿  s7   € ÜÑ:°·	±	Ô:Ó:ˆ	Øò FÜÑE¸4¿9¹9Ô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   è ø€ Ò>¨q˜qŸ{�{Ñ>ùrH   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Ø—‘Ò- §¡°%Ñ7¸A×<NÑ<NÐRWÑ<WÙØ—’Ø�x‘Ø×#Ò#ÚØŸ	™	�AÙ ¨¡Ø ™ÚÜÑ>°D·I±IÔ>Ô>Ù#'ÙØ×#Ñ# 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%   è ø€ ÒE°aˆq�y‰y˜EÐ!Ò1 a§k¡kÓ1ÑEùs   ‚&(F)r±  r+   r
  rÂ  s    r%   Ú_eval_is_imaginaryzMul._eval_is_imaginaryñ  s+   € ÜÑE¸4¿9¹9Ô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û  s   € Ø—‘ò 	ˆ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'   è ø€ ÒXÈA˜Ÿ™Ò>¬)°A·I±IÓ*>À4ÔGÑXùs   ‚/1Tc              3   ó4   K  — | ]  }|j                   –— Œ y ­wrC   )Úis_realr"  s     r%   rG   z*Mul._eval_is_irrational.<locals>.<genexpr>  s   è ø€ Ò,˜Qˆq�y�yÑ,ùrH   F)r+   Úis_irrationalr.   Úremover±  )rJ   ri   r:   Úotherss       r%   Ú_eval_is_irrationalzMul._eval_is_irrational  ss   € Ø—‘ò 		ˆAØ—‘ˆAÙÜ˜dŸi™i›�Ø—‘˜aÔ ÜÑXÐQWÔ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   è ø€ Ò6 q�q—{•{Ñ6ùrH   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‘Ø—’ÜÑ6¨D¯I©IÔ6Ô6Ù ÙØ×*Ò*Ø�u�Ø‘Ø×*Ò*Ø‘ð —‘ %Ñ'Ø�u�ÙÙØ‘Ø—‘ %Ñ'ÙÙØ‘áð7	ð8 �1Š9˜ 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Ø�<Š<˜AŸIšIô Ü—M‘M !Ó$ö3¨QØ()¯	ª	ð —m‘m“o aÓ(ò 3ð 4Ü6>¸q¿s¹s³mñDç!‘kð"ð ØØ‰ˆˆ3Ø—‘ò 	ˆAÜ�1‹vœŸ™‰ØØ�yŠyÙØ�E‰zØØ˜’˜s Q™w×.Ò.Ø‘Ø—‘Ð"Ø�Ø‰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Ø�<Š<˜AŸIšIô Ü—M‘M !Ó$ö3¨QØ()¯	ª	ð —m‘m“o aÓ(ò 3ð 4Ü6>¸q¿s¹s³mñ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  sU   € ð ˆØ—9‘9ò 	$ˆCØ—N’N s§¢ÙØ�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}nŽt%        ‰*«      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  �rÎd}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  ||<   nŽd
}  |||   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Ø�xŠxœ: a¨Ô-Ø—}‘}“Ð&Ø”a—e‘e�8ˆOr$   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 )zýbreak 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Ó&ò 
&�Ù˜a“L�Ù! !›‘��AØœAŸE™E‘>ØŸn™nÓ.‘G�R˜Ü˜A˜q ™t›�AØ�AØ×#Ò#Ø�a“D˜A‘I”Dà—I‘I˜q !˜fÕ%ð
&ð �r�7ˆNr$   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“[‰FˆQ�Ü�q˜!˜B™$“<Ðr$   c                 ó„   — |j                   | j                   z  r| j                   |j                   z  st        | |z  «      S y)zÒif 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   € ð
 —3‘3˜Ÿ™’9 A§C¡C¨!¯#©#¢IÜ˜1˜Q™3“x�Ø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&   øè ø€ Ò=°!‘�a˜‘d“™t E¨!¡H›~Õ-Ñ=ùrö  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à�zŠzØð �8‰8�A‰;× Ò  S§X¡X¨a¡[°1¢_Ø�y‰y˜‰|×%Ò%Ø—9‘9˜Q‘< !Ò#ØŸ:™: s d¨S¨DÓ1Ð1Øò	õ	ô*	 ò	ð ˆÙ˜‹~‰ˆˆ1ØˆØ”A—E‘E‰>Ø—G‘G˜C Ó% a§g¡g¨c°3Ó&7Ñ7ˆEØ—<’<Ø—{‘{ 3¨Ó,Ð,Ø˜Š}Ø�ð —*‘*˜Q‘-ˆØ—‘˜!‘ˆØˆØ×Ò '×"5Ò"5ð ˜Ò Ø!×:Ñ:¸6ÓB‘Ø×ÒØˆIñ ˜%“.‰ˆˆBÙ! #›,‰ˆ�ñ �w×*Ò*¬s°6«{¸aÒ/?Ü‘\¤# f£+¨wÓ7Ó8ˆDØ�E‰E�'ŒNØ˜‰{Ø�&“	˜TÑ!”	à ��&‘	Ø! &¨$¡,Ñ.‰KàˆKð ˆÜˆv‹;œ˜R›Ò à‰BÜ�‹Zœ#˜a›&Ò à‰BØ"Ö#�qˆa�‹dÒ#×.Ñ.¸bÖ/A¸°°!³Ò/AÔBà‰BÜ�‹Z×"Ñ"¤3 q£6Ô*à‰BÜÕ=°uÔ=Ô=àˆBÙØˆIáØ‰DàˆCØ#Ÿk™k›mò ‘
��EØ˜‘d�Ø—
‘
™4  UÓ+Ô,Ø˜2“wØ’Ið	ô
 �s“8ˆDáØˆEÜœ3˜r›7“^ò '�Ù  1¡˜��1’ò'ð ˆEÜ�v“;ˆDØÒ&œAŸJ™JˆEØˆFØˆAÚ˜A ™H¬¨B«Ó/Ø�ð �Ü˜t›ò 3#�AØ˜!˜a™%‘y ‘| v¨a¡y°¡|Ò3ÚØ˜ašØŸ
™
¡4¨¨1¨q©5©	°!©°f¸Q±iÀ±lÓ#CÕDØ˜d Q™hšØŸ
™
¡4¨¨1¨q©5©	°!©°f¸Q±iÀ±lÓ#CÕDØ˜A ™E™ 1™¨°©°1©Ò5ÚàŸ
™
 1œØ˜‘F‘Að3#ô ˜c›(�CÙØ 1š9Ù#Ü&)¨$°£n Ü$'¨¨S£M±&¸¸A¹¸q¹Ø$& q¡E¨!¡H¨s°6¸!±9¸Q±<Ñ/?Ñ$?ó3Añ %A˜B˜qšEð #$˜Cñ !' r¨!¡u¨Q¡x°°A±°q±¸CØ$*¨1¡I¨a¡Lñ=1ñ 21ó !2˜Að
 #&˜Cð "# T¡¨A¡˜BØ!# B¡¨¡¨B¨r©F°1©I¸Ø!'¨¡¨A¡ñ9/ñ -/ð !0˜Aà  štØ#$ t¡8¬c°"«gÒ#5Ø67¸±e¸Q°Z B q¨¨T©¡Ná(.°¨
 AØ67¸±e¸A±g°Y B q¨¨T©¡Nð
 34°C±%°  1 Q¨¡X à ™˜Ø ™˜Ø"˜Ùð —M‘M !Ô$Ø�Q‘�ñC ˜A ™H¬¨B«Ô/ñH Ø�Ið —‘œe A¤s¨2£wÓ/Ô0Øò :�AÙ" B q¡E˜N×/Ñ/°°SÓ9�B�q’Eð:ð
 ˆ<Ø‰BØˆ]Ø‰Bä�U˜DÓ!ˆBàˆØò 	=ˆAØ�E‰zð �a‘D˜5 ™8 B™;Ñ&�Ø—‘™V A q›\Õ*à—‘™V A§F¡F¨3°Ó$4°a¸±dÓ;Õ<ð	=ñ ™ô ˜˜d“^Ð$ uÑ,ˆEØ˜:˜5Ÿ:™: uÐ-Ñ-¨j¨e¯j©j¸"¨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Ø�!‰u�y‰y˜Œ|ð(ØŸ™ qÓ)�Bð ˆI�2ˆIøô "ò (Ø¤§¡˜<Ò'ð(ú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   è ø€ Ò:˜a¨1¨Q©4¯>«>�Q�q•TÑ:ùó   ‚!—
!)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   è ø€ ÒB a°1°Q±4·>³>˜Q˜q�TÑBùrx  )Ú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   øè ø€ Ò<°™: a¨×+Ñ<ùs   ƒ)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–   ù€ Ø�A‰vÜ—u‘u�Ø�yŠyÜ—v‘v�Ø�xŠxÜÔ<°Q·V±VÔ<Ó<Ð<Ø�xŠxÜ°q·v±vÖ>°!™Z¨¨1Õ-Ò>Ð?Ð?Ø�xŠxÙ! !§&¡&¨!Ó,¨Q¯U©UÑ2Ð2Ü—6‘6ˆMùò ?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!  ø€ Ý'Ý?Ý,ò	ð ˆð	Ø—Y‘Yò %�ØŸZ™Z¨›]‘
��sØ—y‘y ”|Ø—K‘K  C Õ)ä$Ð$ð%ô Ñ: 4Ô:Ó:ˆBØˆDØò ‘��1Ù˜Q ™V¨A¯KªK¡q¸QÑ?Ó@�Ø—I‘I˜a 2¨D°t�IÓ<�Ø—V‘V“X�Ø�>Ø˜B’wØ˜R "™W™˜Ø—‘˜A•ñô. �f‰fˆØ59Ö:¨6”—‘˜vÕ&Ð:ˆÐ:ä˜E�?ò 	/ˆCØ47Ö8¨D‘Y˜t QÕ'Ð8ˆEÐ8Ü  %˜[‰NˆF�FÜ˜“KˆEØ˜‘	×&Ó&Ø”s˜F�| Q¨¡XÑ.Ñ.‘ð	/ô	ð ×Ñ˜aÔ Ý>Ý4ðÙ˜d AÓ&¨!Ò+©v°d¸A«Á&ÈÈaÃ.Ò/PØ™5  A¡ q›>Ñ)�Cð �
à�$Š;Ø�s‘
× Ñ   AÓ&¬!¯&©&Ò0°Q¸²UØ×/Ñ/°¸À4Ð/ÓH�ØœŸ™’<Ø�JØ‘5˜˜A™˜q“>Ñ!ˆCØˆ
øôm Ô/´¸IÐFò 	ô œÑB¨4ÔBÓBÓCˆBØ× Ò Ü—V‘V�ØQU×QZÑQZÖ[ÈA�A—I‘I˜a¡7¨1¨R©4£=°tÀ$�IÕGÑ[ùÒ[ˆDÐ[Ý6Ù˜)˜$Ÿ)™) TÐ*×1Ñ1Ó3¸UÈÔNˆCØ�w‰w�uŒ~Ø‘u˜Q ™T 1“~Ñ%�ØŠJð	üò ;ùò 9øð2 #ò Úðú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ó  s7   € Øˆt�y‰yÈtÏyÉyÖYÈ!˜1×,Ñ,¨Q°TÀÐ,ÕEÒ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+   € Øˆt�y‰y°$·)±)Ö<¨Q˜1Ÿ;™;�=Ò<Ð=Ð=ùÒ<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ù  s3   € Øˆt�y‰y°$·)±)¹D¸b¸D±/ÖB¨Q˜1Ÿ;™;�=Ò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ü  s3   € Øˆt�y‰y°·	±	¹$¸B¸$±Ö@¨1˜1Ÿ9™9�;Ò@Ð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ÿ  su   € ô �u‰uˆØˆØ—‘ò 	ˆAØ×)Ñ)°'ÀÐ)ÓG‰DˆAˆqØ�A‰IˆDØœŸ™Š~Ø—‘˜A•ð		ð �Y�T—Y‘Y Ð%Ð%Ð%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   ø€  D§M¡M¸ 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   è ø€ Ò1¡D A q�1—<•<Ñ1ùr{   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 �?Š?Ø×ÒØ" G�U‰Gà˜‘=Ð Ø”!—%‘%ÑØˆØ”—‘�~ØˆØ	”!—-‘-Ñ	©ØˆxˆØ	�ŠÙ˜×*Ò*¨u¯w©w¸!ª|Ø.5¯l©lÖ;¨�A—N‘NÕ$Ð;ˆDÐ;Ø;?×@±4°1°a”[  EÓ*¨AÒ.Ð@ˆDÑ@ÜÑ1¨DÔ1Ô1Ü—~‘~Ø8<ö'>Ø34ô (+§~¡~Ø˜q™T QšY�A�a�b‘E¨Aõ(/ò '>ó ?ð ?ä�5˜'¨EÔ2Ð2Ø	�ŠÜ�W—\‘\Ó"ˆØ�‰8×ÒØ�!‹H˜Ñ‹HØ�Q‰x˜1Š}Ø—	‘	˜!•à�L‰L˜˜EÔ"Ü�~‰~˜eÓ$Ð$à�'‰MˆØ�;Š;˜w×0Ò0Ü—‘  wÐ/Ó0ˆAØˆùò' <ùÛ@ùò'>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‰  sO   € Ø�8Š8Ø—>‘>Ó#‰DˆAˆqØ�{Š{˜qŸxšxÜ'¸¿¹Ö)@°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0ñf> ˜Ó€ó*ó4;òzõ Ý ß &Ð &r$   