
    ^j                        d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZm	Z	 d dl
mZmZ d dl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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! d dl"m#Z# d dl$m%Z% d dl&m'Z' ddl(m)Z)m*Z* erd dlm+Z+  e	de      Z, ed      Z-dZ.dej^                  de0fdZ1dej^                  dej^                  dej^                  fdZ2g dZ3dej$                  de0fdZ4d eee-   ge,f   deee-   ge,ejj                  z  f   fd!Z6d"e0dz  d#e0dz  de0dz  fd$Z7d%ej^                  d&ej^                  dej^                  fd'Z8 G d( d)ejr                        Z: G d* d+ejr                        Z; G d, d-ejr                        Z< G d. d/ejr                        Z= G d0 d1ejr                        Z> G d2 d3e:      Z? G d4 d5ejr                        Z@ G d6 d7ejr                        ZA G d8 d9ejr                        ZB G d: d;ejr                        ZC G d< d=ejr                        ZD G d> d?ee      ZE G d@ dAeEe      ZF G dB dCeEe      ZGdD ZHdE ZI G dF dGejr                        ZJ G dH dIejr                        ZK G dJ dKejr                        ZL G dL dMejr                        ZM G dN dOejr                        ZN G dP dQejr                        ZO G dR dSejr                        ZP G dT dUejr                        ZQ G dV dWejr                        ZR G dX dYejr                        ZS G dZ d[ejr                        ZTd\ ZU eUd]      ZV eUd^      ZW eUd_      ZX eUd`      ZY eUda      ZZ eUdb      Z[ eUdc      Z\ eUdd      Z] eUde      Z^ eUdf      Z_ eUdg      Z` eUdh      Za eUdi      Zb eUdj      Zcdk Zd eddldm      Ze eddndo      Zf eddpdq      Zgy)r    N)Callable)SupportsFloatTYPE_CHECKINGTypeVar)TypeVarTupleUnpack)Ssympify)Expr)Application)_torf	fuzzy_andfuzzy_or)equal_valued)	LatticeOpShortCircuit)ordered)walk)
PRECEDENCE)sift)TorchVersion   )int_oois_infinite)Iterable_T)bound_Ts   exprreturnc                 r    t        | t        j                        xr t        | j                        t
        kD  S N)
isinstancesympyAddlenargs_MAX_ADD_TERMS_FOR_POLY_GCDr!   s    g/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/utils/_sympy/functions.py_is_wide_addr-   )   s&    dEII&W3tyy><W+WW    abc                 r    t        |       st        |      rt        | |      S t        j                  | |      S )zrLike sympy.gcd but avoids polynomial-GCD on wide Add expressions,
    falling back to simple_floordiv_gcd instead.)r-   simple_floordiv_gcdr&   gcdr/   r0   s     r,   safe_gcdr5   -   s.     A,q/"1a((99Q?r.   )FloorDivModularIndexingWhere	PythonModModCleanDiv	CeilToInt
FloorToIntCeilDiv
IntTrueDivFloatTrueDivLShiftRShift!IsNonOverlappingAndDenseIndicatorTruncToFloat
TruncToInt
RoundToIntRoundDecimalToFloatFloatPowPowByNaturalIdentityc                 2   t        | t        j                        xr| | j                  xrn t	        | j
                        dk(  xrT | j
                  d   j                  xr9 | j
                  d   j                  xr | j
                  d   | j
                  d   uS )N   r   r   )r%   r&   r   is_Addr(   _args	is_symbolr+   s    r,   _is_symbols_binary_summationrQ   n   s     	4$ 	/KK	/

Oq 	/ JJqM##	/ JJqM##		/
 JJqMA.r.   fc                      t        j                         dt        t           dt        t
        j                  z  f fd       }|S )Nr)   r"   c                       |  }t        d | D              r8t        |t        j                        st        j                  t	        |            }|S )Nc              3   P   K   | ]  }t        |t        j                           y wr$   )r%   r&   Float.0r/   s     r,   	<genexpr>z-_keep_float.<locals>.inner.<locals>.<genexpr>   s     8az!U[[)8   $&)anyr%   r&   rV   float)r)   rrR   s     r,   innerz_keep_float.<locals>.inner}   sD    h8488u{{B
 E!H%Ar.   )	functoolswrapsr   r   r   r&   rV   )rR   r^   s   ` r,   _keep_floatra   z   sB     __QVC[ R%++%5   Lr.   xyc                     d | |fv ry | |k(  S r$    )rb   rc   s     r,   fuzzy_eqrf      s    1v~6Mr.   pqc                    dt         j                  dt        fddt         j                  dt        ffd}t        j                   ||        ||            }| |z  ||z  }} t        t        t         j                  j                  t         j                  j                  |                   }t         j                  j                  |      }|D ]  t        fd|D              s|z  } |S )a  
    Fast path for sympy.gcd, using a simple factoring strategy.

    We try to rewrite p and q in the form n*e*p1 + n*e*p2 and n*e*q0,
    where n is the greatest common integer factor and e is the largest
    syntactic common factor (i.e., common sub-expression) in p and q.
    Then the gcd returned is n*e, cancelling which we would be left with
    p1 + p2 and q0.

    Note that further factoring of p1 + p2 and q0 might be possible with
    sympy.factor (which uses domain-specific theories). E.g., we are unable
    to find that x*y + x + y + 1 is divisible by x + 1. More generally,
    when q is of the form q1 + q2 (instead of being already factored) it
    might be necessary to fall back on sympy.gcd.
    rb   r"   c                     t         j                  j                  |       D cg c]6  }t        |t        t         j
                  f      rt        t	        |            8 }}t        j                  |      S c c}w r$   )	r&   Mul	make_argsr%   intIntegerabsmathprod)rb   arginteger_coefficientss      r,   integer_coefficientz0simple_floordiv_gcd.<locals>.integer_coefficient   sc     yy**1-+
#U]]34 CM+
 +

 yy-..+
s   ;A4r!   c                     t        t        j                  j                  |             }t	        j
                  t        j                  |      S r$   )mapr&   r'   rl   r_   reducerp   r3   )r!   integer_factorsrt   s     r,   integer_factorz+simple_floordiv_gcd.<locals>.integer_factor   s:    ),!4!4T!:*
 /::r.   c              3   &   K   | ]  }|v  
 y wr$   re   )rX   
base_splitrb   s     r,   rY   z&simple_floordiv_gcd.<locals>.<genexpr>   s     =:qJ=s   )r&   Basicrm   rp   r3   listrv   rk   rl   r'   all)rg   rh   ry   r3   base_splitsdivisor_splitrt   rb   s         @@r,   r2   r2      s    "/u{{ /s /;U[[ ;S ; xxq)>!+<=Cs7AGqA15EII!4!4Q!782K .3YY-@-@-CM ==='C Jr.   c                   D   e Zd ZU dZdZeedf   ed<   dZeed<   dZ	e
ed<   ed	ej                  fd
       Zed	ej                  fd       Zdej                   j"                  d	efdZedej*                  dej*                  d	ej                  dz  fd       Zd	e
dz  fdZy)r6   a  
    We maintain this so that:
    1. We can use divisibility guards to simplify FloorDiv(a, b) to a / b.
    2. Printing out the expression is nicer (compared to say, representing a//b as (a - a % b) / b)

    NB: This is Python-style floor division, round to -Inf
    rM   .nargs#   
precedenceT
is_integerr"   c                      | j                   d   S Nr   r)   selfs    r,   basezFloorDiv.base       yy|r.   c                      | j                   d   S Nr   r   r   s    r,   divisorzFloorDiv.divisor   r   r.   printerc                     |j                  | j                  t        d   dz
        }|j                  | j                  t        d   dz
        }d| d| dS )NAtom      ?(z//))parenthesizer   r   r   r   r   r   r   s       r,   	_sympystrzFloorDiv._sympystr   sW    ##DIIz&/AC/GH&&t||Z5G#5MN4&7)1%%r.   r   r   Nc                 r   |j                   rt        d      t        |      rt        |      rt        j                  S |t        j                  u s|t        j                  u rt        j                  S |j                   rt        j
                  j                  S |j                  rt        |d      r|S |j                  r"t        |d      rt        j                  |d      S ||k(  rt        j
                  j                  S t        |t        j                        rt        |t        j                        rt        |      st        |      rt        |      t        |      z  }|t        j                  k(  rt         S |t        j                   k(  rt          S t        j"                  |      rt        j                  S t        j$                  t        j&                  |            S t        |t        j$                        rDt        |t        j$                        r*t        j$                  t)        |      t)        |      z        S t        |t*              r)t+        |j,                  d   |j,                  d   |z        S t        |t        j$                        rd}g }t        j.                  j1                  |      D ]  }||z  }d }t        |t        j                        rgt3        t        j4                        t3        d      k  rB|j7                  t        j8                        }	t;        d |	D              }
|j                  xr |
}n|j                  }|s|j=                  |       ||z  } t?        |      dk7  r%t+        |t        j.                  |ddiz
  |      |z   S 	 tA        ||      }t        |d      r&t        |t        j.                        rtC        ||      }t        |d      s8t+        t        jD                  ||z        t        jD                  ||z              S 	 y # t        jF                  $ r Y y w xY w)	Ndivision by zeror   r   z1.15.0c              3   :   K   | ]  }|j                   d k(    yw)r   N)rh   )rX   r]   s     r,   rY   z FloorDiv.eval.<locals>.<genexpr>&  s     ,I!QSSAX,Is   evaluateF)$is_zeroZeroDivisionErrorr   r&   nanr	   Zeror   r   rk   Oner%   Numberr\   rp   infr   isnanrn   floorrm   r6   r)   r'   rl   r   __version__atomsRationalr~   appendr(   r2   r5   simplifyPolynomialError)clsr   r   r]   	quotientstermstermquotientquotient_is_integer	rationalsall_rationals_intsr3   s               r,   evalzFloorDiv.eval   s=    ??#$677tW!599599599 499<<77<<??|GQ7K??|GR899T2&&7?77;; tU\\*7ELL1T"k'&:deGn,ADHH}txxiwAyy }}TZZ]33dEMM*z'5==/Q==Tc'l!:;;dH%DIIaL$))A,*@AA gu}}-IE		++D1 *'>
 '+#h		2|%%8 *8+ !)u~~ >I),,Iy,I)I&*2*=*=*TBT'*2*=*='&LL&)I%*( 5zQ TEIIu$Eu$EEwO 
		%dG4CC#
7EII(FtW-Q'NN4#:.w}0M  (  $$ 		s   BP   P65P6c                     | j                   d d \  }}t        |j                  |j                  |j                  |j                  g      ryy )NrM   T)r)   r~   r   is_nonnegativer   rg   rh   s      r,   _eval_is_nonnegativezFloorDiv._eval_is_nonnegativeC  s@    yy!}1allA,<,<a>N>NOPr.   )__name__
__module____qualname____doc__r   tuplerm   __annotations__r   r   boolpropertyr&   r|   r   r   printing
StrPrinterstrr   classmethodrn   r   r   re   r.   r,   r6   r6      s     "E5c?!JJekk     &!:!: &s & V V V%++PTBT V VpdTk r.   r6   c            
           e Zd ZU dZdZeedf   ed<   dZe	ed<   dZ
eed<   ed	ej                  d
ej                  dej                  dej                  dz  fd       Zde	dz  fdZy)r7   zK
    ModularIndexing(a, b, c) => (a // b) % c where % is the C modulus
       .r   Tr   r   r   r   r   modulusr"   Nc                 `   |dk(  s|dk(  rt         j                  j                  S t        |t         j                        r<t        |t         j                        r"t        |t         j                        r||z  |z  S 	 |dk7  rJt        ||      }|dk7  r9t        t        j                  ||z        t        j                  ||z        |      S t        |t         j                        rt        |      sg }d}|j                  D ]  }t        |||z        ||z  k7  st        |t         j                        r|dk  sSt        |t         j                        r=t        |j                  d   t         j                        r|j                  d   dk  rd} n|j                  |        t        |      t        |j                        k7  r|rt        t        |      ||      S t        |t               r*t        |j                  d   |j                  d   |z  |      S y # t         j                  $ r Y aw xY w)Nr   r   TF)r&   r	   r   r%   rn   r5   r7   r   r   r'   r-   r)   rk   r   r(   sumr6   )r   r   r   r   r3   	new_termsall_positiver   s           r,   r   zModularIndexing.evalS  s    19177<<tU]]+7EMM27EMM2GOw..
	!|tW-!8*tcz2w}5  dEII&|D/A-/I!%L		 /D'G"34'8II"47D1H"43&tyy|U]]C IIaL1, (-!((./  9~TYY/L&s9~wHHdH%"499Q<11GQQ? $$ 		s   <AH H-,H-c                 f    | j                   d d \  }}t        |j                  |j                        S )NrM   )r)   rf   r   r   s      r,   r   z$ModularIndexing._eval_is_nonnegative  s.    yy!}1((!*:*:;;r.   )r   r   r   r   r   r   rm   r   r   r   r   r   r&   rn   r|   r   r   re   r.   r,   r7   r7   J  s     "E5c?!JJ4==4+0==4CH==4	t	4 4l<dTk <r.   r7   c            
           e Zd ZU dZdZeedf   ed<   dZeed<   de	dz  fd	Z
de	dz  fd
Zde	dz  fdZedej                  dej                  dej                  dej                  dz  fd       Zy)r8   z#
    Good ol' ternary operator
    r   .r   r   r   r"   Nc                 n    | j                   d   j                  r| j                   d   j                  rdS d S Nr   rM   Tr)   r   r   s    r,   _eval_is_integerzWhere._eval_is_integer  s.    yy|..499Q<3J3JtTPTTr.   c                 n    | j                   d   j                  r| j                   d   j                  rdS d S r   )r)   r   r   s    r,   r   zWhere._eval_is_nonnegative  s9     yy|**tyy|/J/J 	
 	
r.   c                 n    | j                   d   j                  r| j                   d   j                  rdS d S r   r)   is_positiver   s    r,   _eval_is_positivezWhere._eval_is_positive  s.    yy|//DIIaL4L4LtVRVVr.   crg   rh   c                 X    |t         j                  k(  r|S |t         j                  k(  r|S y r$   )r&   truefalse)r   r   rg   rh   s       r,   r   z
Where.eval  s&    

?H%++Hr.   )r   r   r   r   r   r   rm   r   r   r   r   r   r   r   r&   r|   r   re   r.   r,   r8   r8     s     "E5c?!JU$+ U
dTk 
W4$; W U[[ U[[ U[[ U[[SWEW  r.   r8   c                       e Zd ZU dZeedf   ed<   dZeed<   dZe	ed<   e
dej                  d	ej                  d
ej                  dz  fd       Zd
e	dz  fdZd
e	dz  fdZd
efdZy)r9   r   .r   r   r   Tr   rg   rh   r"   Nc                 B   |j                   rt        d      |t        j                  u s||| fv s|dk(  rt        j                  S |j                  r|j                  r||z  S |j                  r=|dk(  r8|j
                  rt        j                  S |j                  rt        j                  S ||z  }|j                  rt        j                  S ||k  }|j                  rt        |      r|j                  r|S t        j                  ||      dk(  rt        j                  S y )NModulo by zeror   rM   r   )r   r   r	   r   	is_Numberis_evenis_oddr   r   
is_Booleanr   r   r&   r:   r   rg   rh   r]   lesss        r,   r   zPythonMod.eval  s     99#$455 ;!A2w,!q&66M ;;1;;q5L ;;16yyvvxxuu E<<66M
 1u??tDzammH99Q?a66Mr.   c                 <    | j                   d   j                  rdS d S Nr   Tr   r   s    r,   r   zPythonMod._eval_is_nonnegative      yy|//t9T9r.   c                 <    | j                   d   j                  rdS d S r   )r)   is_negativer   s    r,   _eval_is_nonpositivezPythonMod._eval_is_nonpositive  r   r.   c                 (   |j                  | j                  d   t        d   dz
        }|j                  | j                  d   t        d   dz
        }| j                  d   j                  rt	        |      nd| d}d| d| d	| d| d
| d| d| S )Nr   r   r   r   zabs(r   r   z % z) < 0 ? z + z : )r   r)   r   r   r   )r   r   rg   rh   abs_qs        r,   _ccodezPythonMod._ccode  s      1z&/AC/GH  1z&/AC/GH))A,22A$qc1#S8A3c!Cwc!CsCCr.   )r   r   r   r   r   rm   r   r   r   r   r   r&   r   r   r   r   r   r   re   r.   r,   r9   r9     s    !E5c?!JJ+UZZ +EJJ +5::3D + +\:dTk ::dTk :D Dr.   r9   c                   8    e Zd ZU dZdZeed<   dZdZe	d        Z
y)r:   r   r   r   Tc                 4   |j                   rt        d      |t        j                  u s||| fv s|dk(  rt        j                  S |j                  r1|j                  r%|dk  rt        |      |dk  rt        |      ||z  S |j                  r=|dk(  r8|j                  rt        j                  S |j                  rt        j                  S ||z  }|j                  rt        j                  S ||k  }|j                  rt        |      r|j                  r|S y y y )Nr   r   r   rM   )r   r   r	   r   r   AssertionErrorr   r   r   r   r   r   r   r   s        r,   r   zMod.eval  s     99#$455 ;!A2w,!q&66M ;;1;;1u$Q''1u$Q''q5L ;;16yyvvxxuu E<<66M
 1u??tDzammH /<z?r.   N)r   r   r   r   r   rm   r   r   r   r   r   re   r.   r,   r:   r:     s-    EJJN+ +r.   r:   c                       e Zd ZdZy)r;   zZ
    Div where we can assume no rounding.
    This is to enable future optimizations.
    N)r   r   r   r   re   r.   r,   r;   r;   '  s    r.   r;   c                   ,    e Zd ZdZed        ZdefdZy)r<   Tc                    |t         j                  t        fv rt        S |t         j                   t         fv rt         S t        |t         j                        r1t        j
                  t        j                  t        |                  S y r$   )	r&   oor   r%   r   rn   rp   ceilr\   r   numbers     r,   r   zCeilToInt.eval3  se     ehh''Muxxi&))7Nfell+==5=!9:: ,r.   r"   c                 J    |j                  | j                  d         }d| dS )Nr   z(int64_t)(ceil())_printr)   r   r   r   s      r,   r   zCeilToInt._ccode=  s'    		!- ++r.   Nr   r   r   r   r   r   r   r   re   r.   r,   r<   r<   0  s%    J; ;, ,r.   r<   c                   ,    e Zd ZdZed        ZdefdZy)r=   Tc                 P   |t         j                  t        fv rt        S |t         j                   t         fv rt         S t        |t         j                        r|S t        |t         j
                        r1t        j                  t        j                  t        |                  S y r$   )	r&   r   r   r%   rn   r   rp   r   r\   r   s     r,   r   zFloorToInt.evalE  sv    ehh''Muxxi&))7Nfemm,Mfell+==E&M!:;; ,r.   r"   c                 J    |j                  | j                  d         }d| dS )Nr   z(int64_t)(floor(r   r   r   s      r,   r   zFloorToInt._ccodeP  '    		!-!&,,r.   Nr   re   r.   r,   r=   r=   B  s%    J< <- -r.   r=   c                       e Zd ZdZdZd Zy)r>   z.
    Div used in indexing that rounds up.
    Tc                     t        j                  |      }t        j                  |      }t        j                  ||      |k(  rt        ||      S t	        ||dz
  z   |      S r   )r&   r   r3   r;   r6   r   r   r   s      r,   __new__zCeilDiv.__new__\  sT    }}T"--(99T7#w.D'**DGaK0'::r.   N)r   r   r   r   r   r  re   r.   r,   r>   r>   U  s     J;r.   r>   c                        e Zd ZdZed        Zy)rA   Tc                 t    |j                   rt        d      |t        t        j                  d      |      z  S Nznegative shift countrM   )r   
ValueErrorrJ   r&   rn   r   r   shifts      r,   r   zLShift.evalh  s2    344l5==#3U;;;r.   Nr   r   r   r   r   r   re   r.   r,   rA   rA   e  s    J< <r.   rA   c                        e Zd ZdZed        Zy)rB   Tc                     |j                   rt        d      t        |t        t	        j
                  d      |            S r
  )r   r  r6   rJ   r&   rn   r  s      r,   r   zRShift.evalr  s4    344l5==+;UCDDr.   Nr  re   r.   r,   rB   rB   o  s    JE Er.   rB   c                      e Zd Zd Zed        Zedeej                  j                  j                     dz  fd       Ze	 d%deej                  j                  j                     dz  deej                  j                  j                     dz  fd       Zed        Zed	        Zed
        Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d  Z%d! Z&d" Z'd# Z(d$ Z)y)&
MinMaxBasec                 &   ddl m} |j                  d|j                        }d |D        }|sd n| j	                  |      }|rC	 t        | j                  |            }|& | j                  |fi |} | j                  |fi |}t        |      }|s| j                  S t        |      dk(  rt        |      j                         S t        j                  | gt!        |      i |}||_        ||_        |S # t        $ r | j                  cY S w xY w)Nr   )global_parametersr   c              3   2   K   | ]  }t        |        y wr$   r
   )rX   rr   s     r,   rY   z%MinMaxBase.__new__.<locals>.<genexpr>~  s     66s   r   )sympy.core.parametersr  popr   "_satisfy_unique_summations_symbols	frozenset_new_args_filterr   zero_collapse_arguments_find_localzerosidentityr(   r}   r   r  r   _argsetunique_summations_symbols)r   original_argsassumptionsr  r   r)   r   objs           r,   r  zMinMaxBase.__new__z  s   ;??:/@/I/IJ66
  77F 	"   !!5!5d!;< )0.s..tC{C ,s++D@K@<<t9>:>>## ll3>>+>(A%
3    xx s   C8 8DDc                 `   t        |      dk7  ry |\  }}|j                         \  }}|j                         \  }}||k7  ry |j                  r|j                  sy ||k(  r|S |j                  r||k  }n|j                  r||kD  }ny | t
        u r|r|S |S | t        u r|r|S |S t        d|        )NrM   impossible )r(   as_coeff_Mulis_comparabler   is_nonpositiveMinMaxr   )	r   valuesr/   r0   a_coeffa_termb_coeffb_terma_is_smallers	            r,   $_collapse_known_multiplicative_termsz/MinMaxBase._collapse_known_multiplicative_terms  s    v;!1..*..*V%%'*?*?gH  "W,L"""W,L#:$1+!+#:$1+!+{3%011r.   r"   Nc                 *   t        |      dk7  ryt        |d   t              r
|d   |d   fn	|d   |d   f\  }}t        |      syt        |      r| j	                  |      S t        |t              r"t        |dd      }|| j	                  |g|      S y)a  
        One common case in some models is building expressions of the form
        max(max(max(a+b...), c+d), e+f) which is simplified to max(a+b, c+d, e+f, ...).
        For such expressions, we call the Max constructor X times (once for each nested
        max) and the expression gets flattened.

        An expensive cost in constructing those expressions is running _collapse_arguments
        and _find_localzeros. However, those two optimizations are unnecessary when the args
        to max are all of the form a+b, c+d, ..etc where each term uses a unique set of symbols.

        This function is used to detect such properties of the expressions we are building
        and if so inform that we do not need to run those optimizations. To detect those,
        we store a property in the expression that tells that this expression is a min/max
        operation over terms that use unique symbols "unique_summations_symbols". This property
        also memoize the set of symbols used in all the terms to make it faster to detect this
        property inductively.

        When we apply max to add a new term, all we need to do is check if the new term uses
        unique symbols (with respect to existing terms and itself).
        Example:
        t = Max(a+b, c+d) ==> satisfies the property
        Max(t, h+j)       ==> h,j not in [a,b,c,d] => satisfy the property.

        The function returns None if the new expression does not satisfy the unique_summations_symbols
        property. Otherwise, it returns a new set of unique symbols.
        rM   Nr   r   r   )r(   r%   r  rQ   _unique_symbolsgetattr)r   r)   lhsrhslhs_unique_summations_symbolss        r,   r  z-MinMaxBase._satisfy_unique_summations_symbols  s    < t9> $q':. !Wd1gq'47# 	c ,C0 (,&&t,, c:&,30$-) -8**C52OPPr.   initial_setc                    |
t               n|j                         }|D ]`  }|j                         D ]K  }t        |t        j
                  j                  j                        s  y||v r  y|j                  |       M b |S )z
        Return seen_symbols if all atoms in all args are all unique symbols,
        else returns None. initial_set can be used to represent initial value for seen_symbols
        N)	setcopyr   r%   r&   coresymbolSymboladd)r   r)   r8  seen_symbolsrr   elements         r,   r3  zMinMaxBase._unique_symbols  s}     !, 3su9I9I9K 	.C99; .!'5::+<+<+C+CD, $$W-.	. r.   c                     |s|S t        t        |            } t        u rt        nt        |d   j                  rg g fx}\  }}|D ]X  }t        |t        t              D ]>  }|j                  d   j                  s|t        |t                 j                  |       @ Z t        j                  }|D ])  }|j                  d   }|j                  s||k  dk(  s(|}+ t        j                  }	|D ])  }|j                  d   }|j                  s||	kD  dk(  s(|}	+  t        u r!|D ]  }
|
j                  s n7|
|k  dk(  s|
} n) t        k(  r |D ]  }
|
j                  s n|
|	kD  dk(  s|
}	 d} t        u r|t        j                  k7  r$t        |}n|	t        j                  k7  rt        |	}|`t        t        |            D ]I  }||   }t        |      s|j                  d   }t        k(  r||kD  n||k  dk(  s; j                  ||<   K  fdt        |      D ](  \  }}||dz   d D cg c]  } ||       c}||dz   d *  fd}t        |      dkD  r ||      }|S c c}w )a}  Remove redundant args.

        Examples
        ========

        >>> from sympy import Min, Max
        >>> from sympy.abc import a, b, c, d, e

        Any arg in parent that appears in any
        parent-like function in any of the flat args
        of parent can be removed from that sub-arg:

        >>> Min(a, Max(b, Min(a, c, d)))
        Min(a, Max(b, Min(c, d)))

        If the arg of parent appears in an opposite-than parent
        function in any of the flat args of parent that function
        can be replaced with the arg:

        >>> Min(a, Max(b, Min(c, d, Max(a, e))))
        Min(a, Max(b, Min(a, c, d)))
        r   TNc           	      T   t        | t        t        f      s| S || j                  v }|s1 | j                  | j                  D cg c]  } ||       c}ddiS t        |       r7 | j                  | j                  D cg c]  }||k7  s	 ||       c}ddiS |S c c}w c c}w )Nr   F)r%   r)  r*  r)   func)air/   condir   dos       r,   rH  z*MinMaxBase._collapse_arguments.<locals>.doh  s    b3*-	<Drww277 ;aAq ;LeLL"c"rww277 Eaa1fAq EVPUVVH !< Es   B 
B%B%r   c                    fd}t        | |d      \  }}|s| S |D cg c]  }t        |j                         }}t        j                  | }|s| S t	        |      }|D cg c]  }||z
  	 }	}t        |	      r,|	D 
cg c]
  }
 |
ddi }}
|j                   |ddi        |ddi}||gz   S c c}w c c}w c c}
w )Nc                     t        |       S r$   )r%   )rr   others    r,   <lambda>zGMinMaxBase._collapse_arguments.<locals>.factor_minmax.<locals>.<lambda>}  s    :c5#9 r.   T)binaryr   F)r   r:  r)   intersectionr}   r~   r   )r)   is_other
other_argsremaining_argsrr   arg_setscommonnew_other_argsarg_setarg_sets_diffsother_args_diffother_args_factoredr   rK  s                r,   factor_minmaxz5MinMaxBase._collapse_arguments.<locals>.factor_minmax|  s    9H)-dHT)J&J 2<<#CHH<H<%%x0F!&\N=EF'Wv-FMF =!FS"T5!#<e#<"T"T%%c?&KU&KL"'"H%"H!%8$999 = G
 #Us   B6#B; C )r}   r   r)  r*  	is_numberr   r)   r'  r%   r   r  ranger(   	enumerate)r   r)   r"  siftedminsmaxsrG  vsmallbigrr   Tr/   a0rE  rZ  rH  rK  s   `               @@r,   r  zMinMaxBase._collapse_arguments  s   0 KGDM"#:EE
 7"$b&(FZT4 =ac* =Avvay..z!S1299!<== LLE FF1I;;AI$#6E ,,C FF1I;;AG#4C cz $C==e, #	$
  "C==c	d*!	"
 AczCLL(EA$}s4y) 3AQA!!U+VVAY(-R!V26!" '*llDG3	 dO 	@DAq15a!eg?2RAY?DQM	@	:0 t9q= &DI @s   9I2c              #   L  K   |D ]  }t        |t              r&|j                  du s|j                  r|j                  st        d| d      || j                  k(  rt        |      || j                  k(  rr|j                  | k(  r|j                  E d{    |  y7 w)z
        Generator filtering args.

        first standard filter, for cls.zero and cls.identity.
        Also reshape ``Max(a, Max(b, c))`` to ``Max(a, b, c)``,
        and check arguments for comparability
        FzThe argument 'z' is not comparable.N)r%   r   is_extended_realr[  r'  r  r  r   r  rD  r)   )r   arg_sequencerr   s      r,   r  zMinMaxBase._new_args_filter  s        	C sD)''50MM#*;*; >#6J!KLLchh"3''$S88##	!	 $s   BB$B"B$c                    t               }d}|D ]\  }|j                  r=||}| t        u rt        ||      })| t        u rt        ||      }>t        d|        |j                  |       ^ || j                  |      }||hS |S t        |      dk(  r|hS t        |      dk(  rOt        t        |            }|dv r|j                  r| t        u r|S |hS |dk(  r|j                  r| t        u r|S |hS |j                  |       |S )a  
        Sequentially allocate values to localzeros.

        When a value is identified as being more extreme than another member it
        replaces that member; if this is never true, then the value is simply
        appended to the localzeros.

        Unlike the sympy implementation, we only look for zero and one, we don't
        do generic is connected test pairwise which is slow
        Nr%  r   r   )g        r   )r:  r   r*  maxr)  minr   r?  r1  r(   nextiterr   r   )r   r+  optionsother_values	num_valuerr   collapsed_valueother_values           r,   r  zMinMaxBase._find_localzeros  s.    u	 	&C}}$ #Icz$'	3$7	$'	3$7	,{3%-@AA  %	& !FF|TO*'((|!;|!tL12KH$)C)C'*cz|B	{BA~+"9"9'*cz|B	{B#r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_algebraicrX   rG  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>       (HA(H   r   r)   rW  s    r,   rL  zMinMaxBase.<lambda>      5(H(H#H r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_antihermitianrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>        - -rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>      u -$%FF- ( r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_commutativerv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>        ++rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>      U +"#&&+ & r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )
is_complexrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>       &Dq||&Drx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>      &DQVV&D!D r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_compositerv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  rw  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r{  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>       #>!AII#>rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>      e#>qvv#>> r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )	is_finiterv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  s     %Baakk%Brx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  s    %B166%B B r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_hermitianrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  rw  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r{  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_imaginaryrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  rw  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r{  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>       'F!'Frx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>      %'Fqvv'F"F r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_irrationalrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>       )Ja!//)Jrx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>      E)J166)J$J r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_nonintegerrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )r(  rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )
is_nonzerorv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  s     "<188"<rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  s    U"<QVV"<< r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_polarrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>        $@AQZZ$@rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>       u$@$@@ r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_primerv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_rationalrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_realrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )rg  rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )is_transcendentalrv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  s      . !.rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  s     .%&VV. ) r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   )r   rv  s     r,   rY   z&MinMaxBase.<lambda>.<locals>.<genexpr>  r  rx  ry  rz  s    r,   rL  zMinMaxBase.<lambda>  r  r.   r$   )*r   r   r   r  r   r1  r:  r&   r<  r=  r>  r  r3  r  r  r  _eval_is_algebraic_eval_is_antihermitian_eval_is_commutative_eval_is_complex_eval_is_composite_eval_is_even_eval_is_finite_eval_is_hermitian_eval_is_imaginary_eval_is_infiniter   _eval_is_irrational_eval_is_negative_eval_is_nonintegerr   r   _eval_is_nonzero_eval_is_odd_eval_is_polarr   _eval_is_prime_eval_is_rational_eval_is_real_eval_is_extended_real_eval_is_transcendental_eval_is_zerore   r.   r,   r  r  y  s   +Z 2 2< 5	UZZ%%	&	-5 5n GK #EJJ$5$5$<$< = D	UZZ%%	&	- $ E EN  4 / /b I EH>MBOHHFDJFJ E<L@NF@NF>M ?Mr.   r  c                   R    e Zd ZdZej
                  Zej                  Zd Z	d Z
d Zy)r*  z=
    Return, if possible, the maximum value of the list.
    c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r  rW   s     r,   rY   z(Max._eval_is_positive.<locals>.<genexpr>       9!9rx  r   r)   r   s    r,   r   zMax._eval_is_positive      9tyy999r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r  rW   s     r,   rY   z+Max._eval_is_nonnegative.<locals>.<genexpr>  s     <Q((<rx  r  r   s    r,   r   zMax._eval_is_nonnegative  s    <$))<<<r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r  rW   s     r,   rY   z(Max._eval_is_negative.<locals>.<genexpr>       :1:rx  r   r)   r   s    r,   r  zMax._eval_is_negative      :		:::r.   N)r   r   r   r   r	   Infinityr  NegativeInfinityr  r   r   r  re   r.   r,   r*  r*    s,     ::D!!H:=;r.   r*  c                   R    e Zd ZdZej
                  Zej                  Zd Z	d Z
d Zy)r)  z=
    Return, if possible, the minimum value of the list.
    c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r  rW   s     r,   rY   z(Min._eval_is_positive.<locals>.<genexpr>)  r  rx  r  r   s    r,   r   zMin._eval_is_positive(  r  r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r  rW   s     r,   rY   z+Min._eval_is_nonnegative.<locals>.<genexpr>,  s     =a))=rx  r  r   s    r,   r   zMin._eval_is_nonnegative+  s    =499===r.   c                 :    t        d | j                  D              S )Nc              3   4   K   | ]  }|j                     y wr$   r  rW   s     r,   rY   z(Min._eval_is_negative.<locals>.<genexpr>/  r  rx  r  r   s    r,   r  zMin._eval_is_negative.  r  r.   N)r   r   r   r   r	   r  r  r  r  r   r   r  re   r.   r,   r)  r)     s,     DzzH;>:r.   r)  c                 L    d}| dk  r|  } |dz  dk(  rdnd}|t        | |      z  S )Nr   r   rM   r   )	_safe_pow)r   expsigns      r,   safe_powr  2  s8    Daxu!GqLqb)D#&&&r.   c                     |dk  rt        d      |dk(  ryt        | |dz        }|t        u rt        S ||z  }|t        j                  kD  rt        S |dz  dk(  r|| z  }|t        j                  kD  rt        S |S )Nr   zExponent must be non-negative.r   rM   )r  r  r   sysmaxsize)r   exponenthalf_expresults       r,   r  r  ;  s    !|9::1}h!m,H6
  F!|q$CKKMMr.   c                   0    e Zd ZU dZdZeed<   ed        Zy)rJ   T2   r   c                    t        |t        j                        rLt        |t        j                        r2t        ||      }|t         t        fv r|S t        j                  |      S t        |t        j                        rt        j
                  ||      S |t        t        j                  fv r/|j                  rt        S |j                  rt        j                  S y y r$   )
r%   r&   rn   r  r   Powr   r   r   zoo)r   r   r  r]   s       r,   r   zPowByNatural.evalZ  s    dEMM*z#u}}/Ms#AfWf%%==##c5==) 99T3''6588$$""!!yy  " %r.   N)	r   r   r   r   r   rm   r   r   r   re   r.   r,   rJ   rJ   U  s#    JJ! !r.   rJ   c                   0    e Zd ZU dZdZeed<   ed        Zy)rI   T<   r   c                     t        |t        j                        rEt        |t        j                        r*t        j                  t	        |      t	        |      z        S y y r$   )r%   r&   r   rV   r\   )r   r   r  s      r,   r   zFloatPow.evalu  sD     dELL)jell.K;;uT{eCj899 /L)r.   N	r   r   r   r  r   rm   r   r   r   re   r.   r,   rI   rI   p  s#    GJ: :r.   rI   c                   0    e Zd ZU dZdZeed<   ed        Zy)r@   Tr   r   c                     |j                   rt        d      t        |t        j                        rEt        |t        j                        r*t        j
                  t        |      t        |      z        S y y Nr   )r   r   r%   r&   r   rV   r\   r  s      r,   r   zFloatTrueDiv.eval  sW    
 ??#$677dELL)j%,,.O;;uT{U7^;<< /P)r.   Nr  re   r.   r,   r@   r@     s#    GJ= =r.   r@   c                   <    e Zd ZU dZdZeed<   ed        Zde	fdZ
y)r?   Tr   r   c                    |j                   rt        d      t        |t        j                        rZt        |t        j                        r@t        |      st        |      r*t        j                  t        |      t        |      z        S t        |t        j                        rEt        |t        j                        r*t        j                  t        |      t        |      z        S y y r  )
r   r   r%   r&   r   r   rV   r\   rn   rm   r  s      r,   r   zIntTrueDiv.eval  s    ??#$677 tU\\*7ELL1T"k'&: ;;uT{U7^;<<dEMM*z'5==/Q;;s4y3w<788 0R*r.   r"   c                     |j                  | j                  d   t        d   dz
        }|j                  | j                  d   t        d   dz
        }d| d| dS )Nr   r   r   r   z((int)z/(int)r   )r   r)   r   r   s       r,   r   zIntTrueDiv._ccode  s_    ##DIIaL*V2Ds2JK&&tyy|Z5G#5MNvVG9A..r.   N)r   r   r   r  r   rm   r   r   r   r   r   re   r.   r,   r?   r?     s/    GJ9 9/ /r.   r?   c                        e Zd ZdZed        Zy)rC   Tc           	         t        |      dz  dk7  rt        dt        |             t        |      dz  }|d| }||d  }ddlm} t	        d |D              r7 ||D cg c]  }t        |       c}|D cg c]  }t        |       c}      S |dk(  r0|d   j                  r	|d   dk(  ry|d   j                  r	|d   dk  ryt	        d |D              r|dk(  rt        d      t        t        t        ||d	
      t        j                  d            dd	i\  }}t	        d |d d D              r?|d d dz   } ||D cg c]  }t        |       c}|D cg c]  }t        |       c}      S y c c}w c c}w c c}w c c}w )NrM   r   z*expected an even number of arguments, got )!eval_is_non_overlapping_and_densec              3   P   K   | ]  }t        |t        j                           y wr$   r%   r&   rn   rW   s     r,   rY   z9IsNonOverlappingAndDenseIndicator.eval.<locals>.<genexpr>  s     :z!U]]+:rZ   r   c              3   P   K   | ]  }t        |t        j                           y wr$   r  rW   s     r,   rY   z9IsNonOverlappingAndDenseIndicator.eval.<locals>.<genexpr>  s     =z!U]]+=rZ   zdim must not be zeroT)strict)keyr  c              3   P   K   | ]  }t        |t        j                           y wr$   r  rW   s     r,   rY   z9IsNonOverlappingAndDenseIndicator.eval.<locals>.<genexpr>  s     FA:a/FrZ   r   )*   )r(   r   %torch.fx.experimental.symbolic_shapesr  r~   rm   r   zipsortedoperator
itemgetter)	r   r)   dimsizesstridesr  r/   s_sizes	s_stridess	            r,   r   z&IsNonOverlappingAndDenseIndicator.eval  s   t9q=A <SYKH  $i1nQsst*	
 :T::4!&'AQ'')BQ#a&)B  !8qz##
aQx!!eAhl =W==ax$%;<< "%E748h>Q>QRS>TU""GY
 F"FF!#2,. 9%,-SV-	/J1A/J  K ()BD ./Js   E47E9
E>F
Nr  re   r.   r,   rC   rC     s    J5 5r.   rC   c                        e Zd ZdZed        Zy)rD   Tc                     |t         j                  t         j                   fv r|S t        |t         j                        r1t        j                  t        j                  t        |                  S y r$   )r&   r   r%   r   rV   rp   truncr\   r   s     r,   r   zTruncToFloat.eval   sO    ehh	**Mfell+ ;;tzz%-899	 ,r.   Nr   r   r   r  r   r   re   r.   r,   rD   rD     s    G: :r.   rD   c                   ,    e Zd ZdZed        ZdefdZy)rE   Tc                    |t         j                  t        fv rt        S |t         j                   t         fv rt         S t        |t         j                        r1t        j
                  t        j                  t        |                  S y r$   )	r&   r   r   r%   r   rn   rp   r*  r\   r   s     r,   r   zTruncToInt.eval  se     ehh''Muxxi&))7Nfell+==E&M!:;; ,r.   r"   c                 J    |j                  | j                  d         }d| dS )Nr   z(int64_t)(trunc(r   r   r   s      r,   r   zTruncToInt._ccode  r  r.   Nr   re   r.   r,   rE   rE     s%    J< <- -r.   rE   c                        e Zd ZdZed        Zy)rF   Tc                     |t         j                  u rt        S |t         j                   u rt         S t        |t         j                        r(t        j
                  t        t        |      d            S y r   )r&   r   r   r%   r   rn   roundr\   r   s     r,   r   zRoundToInt.eval"  sW     UXXMehhY7Nfell+==uV}a!899 ,r.   Nr  re   r.   r,   rF   rF     s    J: :r.   rF   c                        e Zd ZdZed        Zy)rG   Tc                     t        |t        j                        rLt        |t        j                        r1t        j                  t        t        |      t        |                  S y y r$   )r%   r&   r   rn   rV   r1  r\   rm   )r   r   ndigitss      r,   r   zRoundDecimal.eval@  sF     fell+
7EMM0R;;uU6]CLABB 1S+r.   Nr+  re   r.   r,   rG   rG   =  s    GC Cr.   rG   c                   ,    e Zd ZdZed        ZdefdZy)rH   Tc                 "   |t         j                  t         j                   fv r|S t        |t         j                        rt        j                  t        |            S |t        u rt         j                  S |t         u rt         j                   S y r$   )r&   r   r%   rn   rV   rm   r   r   s     r,   r   zToFloat.evalK  sk    ehh	**Mfemm,;;s6{++V88OfWHH9 r.   r"   c                 J    |j                  | j                  d         }d| dS )Nr   z	(double)(r   r   r   s      r,   r   zToFloat._ccodeW  s'    		!-6(!$$r.   N)r   r   r   r  r   r   r   r   re   r.   r,   rH   rH   H  s%    G	 	% %r.   rH   c                        e Zd ZdZdZdefdZdefdZd Zd Z	e
d        Ze
d	        Zd
 ZdefdZd Z fdZ fdZ fdZ fdZdefdZ xZS )rK   z4
    Prevents expansion and other optimizations
    
   r"   c                 (    d| j                   d    dS )Nz	Identity(r   r   r   r   s    r,   __repr__zIdentity.__repr__c  s    499Q<.**r.   c                 F    d|j                  | j                  d          dS )z+Controls how sympy's StrPrinter prints thisr   r   r   )doprintr)   )r   r   s     r,   r   zIdentity._sympystrf  s#    7??499Q<0133r.   c                 4    | j                   d   j                  S r   )r)   r  r   s    r,   r  zIdentity._eval_is_realj  s    yy|###r.   c                 4    | j                   d   j                  S r   r   r   s    r,   r   zIdentity._eval_is_integerm  s    yy|&&&r.   c                 |    t        | j                  d   j                  xr | j                  d   j                        S r   )r   r)   r[  r'  r   s    r,   r[  zIdentity.is_numberp  s0     DIIaL**Ityy|/I/IJJr.   c                 F    t        | j                  d   j                        S r   )r   r)   r'  r   s    r,   r'  zIdentity.is_comparablev  s     DIIaL..//r.   c                      | j                   d   S r   r   )r   hintss     r,   _eval_expand_identityzIdentity._eval_expand_identity{  r   r.   c                 2    t        | j                  d         S r   )rm   r)   r   s    r,   __int__zIdentity.__int__  s    499Q<  r.   c                    | j                   d   }t        |t              rt        j                  |      }t        |t        j
                        sy|j                  r|j                  r|j                  sy|j                  r|j                  r|j                  sy |||      rt        j                  j                  S t        j                  j                  S )z
        Fast path for comparing wrapped numeric atomics against other numeric atomics.
        Keep compound expressions on SymPy's default symbolic path.
        r   N)r)   r%   rm   r&   rn   r   is_Atomr[  r'  r	   r   r   )r   rK  oprr   s       r,   _identity_atom_comparezIdentity._identity_atom_compare  s    
 iileS!MM%(E%,#2C2C%//e6I6I!#u~uww||@577==@r.   c                 P    | j                  |d       }||S t        | 	  |      S )Nc                     | |k\  S r$   re   r4   s     r,   rL  z!Identity.__ge__.<locals>.<lambda>  
    a1f r.   )rJ  super__ge__r   rK  out	__class__s      r,   rO  zIdentity.__ge__  .    ))%1DEos@57>%+@@r.   c                 P    | j                  |d       }||S t        | 	  |      S )Nc                     | |kD  S r$   re   r4   s     r,   rL  z!Identity.__gt__.<locals>.<lambda>  
    a!e r.   )rJ  rN  __gt__rP  s      r,   rW  zIdentity.__gt__  .    ))%1CDos@57>%+@@r.   c                 P    | j                  |d       }||S t        | 	  |      S )Nc                     | |k  S r$   re   r4   s     r,   rL  z!Identity.__le__.<locals>.<lambda>  rM  r.   )rJ  rN  __le__rP  s      r,   r[  zIdentity.__le__  rS  r.   c                 P    | j                  |d       }||S t        | 	  |      S )Nc                     | |k  S r$   re   r4   s     r,   rL  z!Identity.__lt__.<locals>.<lambda>  rV  r.   )rJ  rN  __lt__rP  s      r,   r^  zIdentity.__lt__  rX  r.   c                 2    t        | j                  d         S r   )r\   r)   r   s    r,   	__float__zIdentity.__float__  s    TYYq\""r.   )r   r   r   r   r   r   r;  r   r  r   r   r[  r'  rD  rm   rF  rJ  rO  rW  r[  r^  r\   r`  __classcell__)rR  s   @r,   rK   rK   \  s     J+# +4C 4$' K K
 0 0! !A AAAA#5 #r.   rK   c                 d      G  fddt         j                        }d z   }||_        ||_        |S )Nc                   0    e Zd ZdZW  ZeZe fd       Zy)+make_opaque_unary_fn.<locals>.OpaqueUnaryFna  
        Unlike the builtin sympy functions on real numbers like sympy.sqrt,
        these equivalents do not do any nontrivial reasoning besides
        constant propagation.  This helps avoid performing transformations
        that are valid for real numbers but are invalid for floating point;
        in particular, while we are willing to make optimizations that change
        numerics for Tensor compute, we are NOT willing to make optimizations
        that change numerics for size compute.
        c                 j   t        |t        j                  t        j                  f      r3	 t        j                   t	        t
              t        |                  S |t        j                  t        j                   t        j                  t        j                   t        t         fv rc|t        u rt        j                  }|t         u rt        j                   }dk(  rt        j                  |d      S  t	        t              |      S y # t        $ r  t	        t              |      cY S w xY w)Nlog2rM   )r%   r&   rn   rV   r4  rp   r\   OverflowErrorr   r	  r   log)r   r/   names     r,   r   z0make_opaque_unary_fn.<locals>.OpaqueUnaryFn.eval  s    !emmU[[9:3 ;;':wtT':58'DEE
 uxx%((EII		z6F7SS;A<	A6> 99Q?*+wud+A.. % 3/75$/223s   1D D21D2N)	r   r   r   r   _torch_handler_namemake_opaque_unary_fn_torch_unpicklerr   r   )ri  s   r,   OpaqueUnaryFnrd    s(    	 #/		 
	r.   rm  OpaqueUnaryFn_)r&   Functionr   r   )ri  rm  nms   `  r,   rk  rk    s6    $ $L 
D	 BM!#Mr.   sqrtcoscoshsinsinhtantanhasinacosatanr  rh  asinhrf  c                       dk(  r
t         d   n, dk(  r
t         d   n dk(  r
t         d   nt        d         G  fdd	t        j                        }d
 z   }||_        ||_        |S )Nbitwise_and
BitwiseAndbitwise_xor
BitwiseXor
bitwise_or	BitwiseOrzunrecognized c                   d    e Zd ZU W  ZW Zeed<    ej                  e	W       Z
efd       Zy))make_opaque_bitwise_fn.<locals>.BitwiseFnr   )real_op_namec                    |j                   r#|j                   r t        t              ||      S |j                   rt        j                  |rdnd      }|j                   rt        j                  |rdnd      }t        |t        j                  t        f      r\t        |t        j                  t        f      r<t        j                   t        t              t        |      t        |                  S y )Nr   r   )r   r4  r!  r&   rn   r%   rm   )r   r/   r0   r  s      r,   r   z.make_opaque_bitwise_fn.<locals>.BitwiseFn.eval  s    ||6wx6q!<<||MMq!a0||MMq!a0!emmS12zEMM3'8 }}%DWX|%DSVSQRV%TUUr.   N)r   r   r   rj  r   rm   r   r_   partialmake_opaque_bitwise_fnrl  r   r   )ri  precr  s   r,   	BitwiseFnr    s?    "
C,9,,"
 
	 
	r.   r  
BitwiseFn_)r   r   r&   ro  r   r   )ri  r  r  rp  r  s   ``  @r,   r  r    s    },'		,'		+&}TF344 ENN * 
	BIIr.   r}  and_r  or_r  xor)hr_   rp   r!  r   collections.abcr   typingr   r   r   typing_extensionsr   r   r&   r	   
sympy.corer   sympy.core.exprr   sympy.core.functionr   sympy.core.logicr   r   r   sympy.core.numbersr   sympy.core.operationsr   r   sympy.core.sortingr   sympy.core.traversalr   sympy.printing.precedencer   sympy.utilities.iterablesr   torch.torch_versionr   numbersr   r   r   r   r   r*   r|   r   r-   r5   __all__rQ   rV   ra   rf   r2   ro  r6   r7   r8   r9   r:   r;   r<   r=   r>   rA   rB   r  r*  r)  r  r  rJ   rI   r@   r?   rC   rD   rE   rF   rG   rH   rK   rk  OpaqueUnaryFn_sqrtOpaqueUnaryFn_cosOpaqueUnaryFn_coshOpaqueUnaryFn_sinOpaqueUnaryFn_sinhOpaqueUnaryFn_tanOpaqueUnaryFn_tanhOpaqueUnaryFn_asinOpaqueUnaryFn_acosOpaqueUnaryFn_atanOpaqueUnaryFn_expOpaqueUnaryFn_logOpaqueUnaryFn_asinhOpaqueUnaryFn_log2r  BitwiseFn_bitwise_andBitwiseFn_bitwise_orBitwiseFn_bitwise_xorre   r.   r,   <module>r     s      
 $ 8 8 2      + 7 7 + 9 & % 0 * , ( ( T'5
 ! Xu{{ Xt X   N4	uzz 	d 	r!"vc{mR%++--. t t t )5;; )5;; )5;; )|yu~~ yxB<enn B<JENN >?D ?DF3%.. 3lx , ,$- -&;enn ; <U^^ <EU^^ ER?y R?j;*k ;$:*k :$'4!5>> !6:u~~ :,=5>> =2/ /B9 9z:5>> :- -&: :<C5>> C%enn %(G#u~~ G#T+^ *&1 (/ )&1 (/ )&1 (/ )&1 )&1 )&1 )&1 (/ (/ *73 )&1 #L /}fE -lEB .}eD r.   