
    \hA                        S r SSKJr  SSKJr  SSKJr  SSKJr  SSK	J
r
  SSKJr  SSKJrJr  SS	KJr  SS
KJr  SSKJrJr  SSKJr  SSKJr  SSKJr  SSKJrJr  SSK J!r!  SSK"J#r#  SSK$J%r%  SSKJ&r&  SSKJ'r'  SSK J(r(  SSK)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5   " S S\65      r7 " S S\*5      r8 " S S\85      r9 " S S\+\85      r: " S S \,\:5      r; " S! S"\5\35      r< " S# S$\-5      r= " S% S&\/\=5      r> " S' S(\.\=5      r?g))*zq
Finite Discrete Random Variables Module

See Also
========
sympy.stats.frv_types
sympy.stats.rv
sympy.stats.crv
    )product)Sum)Basic)cacheit)Lambda)Mul)Inan)Eq)S)DummySymbolsympifyexp)	Piecewise)AndOr)Intersection)Dict)Logic)
Relational)_sympify	FiniteSet)RandomDomainProductDomainConditionalDomainPSpaceIndependentProductPSpaceSinglePSpacerandom_symbolssumsetsrv_subsNamedArgsMixinDensityDistributionc                   .    \ rS rSrSrS r\S 5       rSrg)FiniteDensity$   z
A domain with Finite Density.
c                 ,    [        U5      nX;   a  X   $ g)zv
Make instance of a class callable.

If item belongs to current instance of a class, return it.

Otherwise, return 0.
r   r   )selfitems     G/var/www/auris/envauris/lib/python3.13/site-packages/sympy/stats/frv.py__call__FiniteDensity.__call__(   s     t}<:    c                     [        U 5      $ )z
Return item as dictionary.
)dictr-   s    r/   r4   FiniteDensity.dict6   s    
 Dzr2    N)	__name__
__module____qualname____firstlineno____doc__r0   propertyr4   __static_attributes__r7   r2   r/   r*   r*   $   s       r2   r*   c                   ^    \ rS rSrSrSr\S 5       r\S 5       r\S 5       r	S r
S rS	 rS
rg)FiniteDomain=   zG
A domain with discrete finite support

Represented using a FiniteSet.
Tc                 :    [        S U R                   5       5      $ )Nc              3   *   #    U  H	  u  pUv   M     g 7fNr7   ).0symvals      r/   	<genexpr>'FiniteDomain.symbols.<locals>.<genexpr>G   s     ;]]s   )r   elementsr5   s    r/   symbolsFiniteDomain.symbolsE   s    ;T]];;;r2   c                      U R                   S   $ Nr   argsr5   s    r/   rJ   FiniteDomain.elementsI       yy|r2   c           
      v    [        U R                   Vs/ s H  n[        [        U5      5      PM     sn6 $ s  snf rD   )r   rJ   r   r4   )r-   els     r/   r4   FiniteDomain.dictM   s+    DMMBMb4R>MBCCBs   6c                     XR                   ;   $ rD   )rJ   r-   others     r/   __contains__FiniteDomain.__contains__Q   s    %%r2   c                 6    U R                   R                  5       $ rD   )rJ   __iter__r5   s    r/   r\   FiniteDomain.__iter__T   s    }}%%''r2   c                     [        U  VVVs/ s H)  n[        U VVs/ s H  u  p#[        X#5      PM     snn6 PM+     snnn6 $ s  snnf s  snnnf rD   )r   r   r   )r-   r.   rF   rG   s       r/   
as_booleanFiniteDomain.as_booleanW   s<    $O$$Ct<t83"S,t<=$OPP<Os   AA	AAr7   N)r8   r9   r:   r;   r<   	is_Finiter=   rK   rJ   r4   rY   r\   r_   r>   r7   r2   r/   r@   r@   =   sZ    
 I< <   D D&(Qr2   r@   c                   j    \ rS rSrSrS r\S 5       r\S 5       r\S 5       r	\S 5       r
S rS	 rS
rg)SingleFiniteDomain[   z]
A FiniteDomain over a single symbol/set

Example: The possibilities of a *single* die roll.
c                     [        U[        5      (       d  [        U[        5      (       d  [        U6 n[        R                  " XU5      $ rD   )
isinstancer   r   r   __new__)clssymbolsets      r/   rg   SingleFiniteDomain.__new__b   s6    #y))3--S/C}}S#..r2   c                      U R                   S   $ rN   rO   r5   s    r/   ri   SingleFiniteDomain.symbolh   rR   r2   c                 ,    [        U R                  5      $ rD   )r   ri   r5   s    r/   rK   SingleFiniteDomain.symbolsl   s    %%r2   c                      U R                   S   $ N   rO   r5   s    r/   rj   SingleFiniteDomain.setp   rR   r2   c           	      ~    [        U R                   Vs/ s H  n[        U R                  U445      PM     sn6 $ s  snf rD   )r   rj   	frozensetri   r-   elems     r/   rJ   SingleFiniteDomain.elementst   s4    $((S($9t{{D&9%<=(STTSs   ":c                 0   ^  U 4S jT R                    5       $ )Nc              3   T   >#    U  H  n[        TR                  U445      v   M     g 7frD   )ru   ri   rE   rw   r-   s     r/   rH   .SingleFiniteDomain.__iter__.<locals>.<genexpr>y   s%     Ghd	DKK.011h   %(rj   r5   s   `r/   r\   SingleFiniteDomain.__iter__x   s    GdhhGGr2   c                 h    [        U5      S   u  p#X R                  :H  =(       a    X0R                  ;   $ rN   )tupleri   rj   )r-   rX   rF   rG   s       r/   rY   SingleFiniteDomain.__contains__{   s)    <?kk!5cXXo5r2   r7   N)r8   r9   r:   r;   r<   rg   r=   ri   rK   rj   rJ   r\   rY   r>   r7   r2   r/   rc   rc   [   si    /   & &   U UH6r2   rc   c                   .    \ rS rSrSrS r\S 5       rSrg)ProductFiniteDomain   z~
A Finite domain consisting of several other FiniteDomains

Example: The possibilities of the rolls of three independent dice
c                 8    [        U R                  6 nS U 5       $ )Nc              3   8   #    U  H  n[        U5      v   M     g 7frD   )r$   )rE   itemss     r/   rH   /ProductFiniteDomain.__iter__.<locals>.<genexpr>   s     5H5H   )r   domains)r-   proditers     r/   r\   ProductFiniteDomain.__iter__   s    DLL)5H55r2   c                     [        U 6 $ rD   r   r5   s    r/   rJ   ProductFiniteDomain.elements   s    $r2   r7   N)	r8   r9   r:   r;   r<   r\   r=   rJ   r>   r7   r2   r/   r   r      s     6    r2   r   c                   F    \ rS rSrSrS rS rS rS r\	S 5       r
S rS	rg
)ConditionalFiniteDomain   z
A FiniteDomain that has been restricted by a condition

Example: The possibilities of a die roll under the condition that the
roll is even.
c                 T    USL a  U$ [        U5      n[        R                  " XU5      $ )z8
Create a new instance of ConditionalFiniteDomain class
T)r%   r   rg   )rh   domain	conditionconds       r/   rg   ConditionalFiniteDomain.__new__   s,     My!}}S$//r2   c                     U R                   R                  [        U5      5      nUS;   a  U$ UR                  (       a  UR                  UR
                  :H  $ [        S[        U5      -  5      e)z
Test the value. If value is boolean, return it. If value is equality
relational (two objects are equal), return it with left-hand side
being equal to right-hand side. Otherwise, raise ValueError exception.
)TFzUndecidable if %s)r   xreplacer4   is_Equalitylhsrhs
ValueErrorstr)r-   rw   rG   s      r/   _testConditionalFiniteDomain._test   sX     nn%%d4j1-J__77cgg%%,s3x788r2   c                 N    XR                   ;   =(       a    U R                  U5      $ rD   )
fulldomainr   rW   s     r/   rY   $ConditionalFiniteDomain.__contains__   s    '=DJJu,==r2   c                 0   ^  U 4S jT R                    5       $ )Nc              3   X   >#    U  H  nTR                  U5      (       d  M  Uv   M!     g 7frD   )r   r{   s     r/   rH   3ConditionalFiniteDomain.__iter__.<locals>.<genexpr>   s     EDJJt4Ds   *	*)r   r5   s   `r/   r\    ConditionalFiniteDomain.__iter__   s    EEEr2   c           	      
   [        U R                  [        5      (       aU  [        U R                  R                   Vs/ s H-  n[        U R                  R                  U445      U ;   d  M+  UPM/     sn6 $ [        S5      es  snf )Nz7Not implemented on multi-dimensional conditional domain)rf   r   rc   r   rj   ru   ri   NotImplementedErrorrv   s     r/   rj   ConditionalFiniteDomain.set   s    doo'9::0C0C X0C"+doo.D.Dd-K,M"NRV"V  $0C X Y Y &IK KXs   *B +B c                 ,    [         R                  U 5      $ rD   )r@   r_   r5   s    r/   r_   "ConditionalFiniteDomain.as_boolean   s    &&t,,r2   r7   N)r8   r9   r:   r;   r<   rg   r   rY   r\   r=   rj   r_   r>   r7   r2   r/   r   r      s7    09>F K K-r2   r   c                       \ rS rSrS r\S 5       r\\S 5       5       r	S r
\S 5       r\" S 5      r\" S 5      r\" S	 5      r\" S
 5      r\" S 5      rS rS rSrg)SingleFiniteDistribution   c                 b    [        [        [        U5      5      n[        R                  " U /UQ76 $ rD   )listmapr   r   rg   )rh   rP   s     r/   rg    SingleFiniteDistribution.__new__   s'    C&'}}S(4((r2   c                      g rD   r7   rO   s    r/   checkSingleFiniteDistribution.check   s    r2   c                     U R                   (       a  [        U 5      $ U R                   Vs0 s H  oU R                  U5      _M     sn$ s  snf rD   )is_symbolicr'   rj   pmf)r-   ks     r/   r4   SingleFiniteDistribution.dict   s=     4= (,11488A;111s   A	c                     [        5       erD   r   r-   rP   s     r/   r   SingleFiniteDistribution.pmf   s    !##r2   c                     [        5       erD   r   r5   s    r/   rj   SingleFiniteDistribution.set   s    !##r2   c                 .    U R                   R                  $ rD   )r4   valuesr5   s    r/   <lambda>!SingleFiniteDistribution.<lambda>   s    499#3#3r2   c                 .    U R                   R                  $ rD   )r4   r   r5   s    r/   r   r      s    $))//r2   c                     g)NFr7   r5   s    r/   r   r      s    r2   c                 .    U R                   R                  $ rD   )r4   r\   r5   s    r/   r   r      s    TYY%7%7r2   c                 .    U R                   R                  $ rD   )r4   __getitem__r5   s    r/   r   r      s    		(=(=r2   c                      U R                   " U6 $ rD   )r   r   s     r/   r0   !SingleFiniteDistribution.__call__   s    xxr2   c                     XR                   ;   $ rD   r~   rW   s     r/   rY   %SingleFiniteDistribution.__contains__   s      r2   r7   N)r8   r9   r:   r;   rg   staticmethodr   r=   r   r4   r   rj   r   r   r   r\   r   r0   rY   r>   r7   r2   r/   r   r      s    )   2  2
$ $ $ 34F12E-.K78H=>K!r2   r   c                       \ rS rSrSrSrS rS rS rS r	\
S 5       r\
SS	 j5       r\
S
 5       r\
S 5       rSS jrS rS rS rSS jrSrg)FinitePSpace   zX
A Finite Probability Space

Represents the probabilities of a finite number of events.
Tc                     UR                  5        VVs0 s H  u  p4[        U5      [        U5      _M     nnn[        U5      n[        R                  " XU5      nX&l        U$ s  snnf rD   )r   r   r   r    rg   _density)rh   r   densitykeyrG   public_densityobjs          r/   rg   FinitePSpace.__new__   s_     '1 /HC 3<- / 	 1gnnS.9
1s   !A"c                 ,   [        U5      nU R                  n[        [        UR	                  5       5      S   [
        5      (       a   UR                  U[        R                  5      $ UR                  [        U5      S   S   [        R                  5      $ )Nr   rr   )
r   r   rf   r   keysr   getr   Zeror   )r-   rw   r   s      r/   prob_ofFinitePSpace.prob_of   sh    t}--d7<<>*1-y99;;tQVV,,{{5;q>!,aff55r2   c                 z   ^  [        U 4S j[        U5       5       5      (       d   e[        T R                  U5      $ )Nc              3   T   >#    U  H  oR                   TR                  ;   v   M     g 7frD   )ri   rK   )rE   rr-   s     r/   rH   %FinitePSpace.where.<locals>.<genexpr>  s     O5N88t||+5Nr}   )allr#   r   r   r-   r   s   ` r/   whereFinitePSpace.where  s0    O^I5NOOOOO&t{{I>>r2   c                 
   [        XR                  5      n[        5       nU R                   HS  nUR	                  [        U5      5      nU R                  U5      nUR                  U[        R                  5      U-   X$'   MU     U$ rD   )
r%   r   r*   r   r   r4   r   r   r   r   )r-   exprdrw   rG   probs         r/   compute_densityFinitePSpace.compute_density  sg    t[[)OKKD--T
+C<<%DUU3'$.AF   r2   c                     U R                  U5      n[        R                  n/ n[        U5       H  nX%   nX6-  nUR	                  XS45        M     [        U5      $ rD   )r   r   r   sortedappendr4   )r-   r   r   cum_probcdfr   r   s          r/   compute_cdfFinitePSpace.compute_cdf  sW      &66!9C6DHJJ' 
 Cyr2   c                     U R                  U5      n[        UR                  5       5      n[        US S9nU(       a!  U VVs/ s H  u  pgU[	        U5      4PM     nnnU$ s  snnf )Nc                     U S   $ rq   r7   )val_cumprobs    r/   r   )FinitePSpace.sorted_cdf.<locals>.<lambda>  s    [^r2   )r   )r   r   r   r   float)r-   r   python_floatr   r   sorted_itemsvr   s           r/   
sorted_cdfFinitePSpace.sorted_cdf  sh    t$SYY[!e)KL'35'3 h0'3  55s   A c                    ^ U R                  U5      n[        SSS9m[        T[        U4S jUR	                  5        5       5      5      $ )NtTrealc              3   X   >#    U  H  u  p[        [        U-  T-  5      U-  v   M!     g 7frD   )r   r	   rE   r   r   r   s      r/   rH   ?FinitePSpace.compute_characteristic_function.<locals>.<genexpr>*  s#     ?YcaS1QZ\Ys   '*r   r   r   sumr   r-   r   r   r   s      @r/   compute_characteristic_function,FinitePSpace.compute_characteristic_function%  s=      &#D!a?QWWY??@@r2   c                    ^ U R                  U5      n[        SSS9m[        T[        U4S jUR	                  5        5       5      5      $ )Nr   Tr  c              3   J   >#    U  H  u  p[        UT-  5      U-  v   M     g 7frD   r   r  s      r/   rH   BFinitePSpace.compute_moment_generating_function.<locals>.<genexpr>1  s     =9CAS1XaZ9s    #r  r  s      @r/   "compute_moment_generating_function/FinitePSpace.compute_moment_generating_function,  s=      &#D!a=1779==>>r2   Nc                    U=(       d    U R                   n[        X5      nU R                   Vs/ s H  o@R                  U5      PM     nn[	        U[
        [        45      (       a_  U R                   Vs/ s H  n[        U5      S   S   PM     nnU R                   Vs/ s H  oAR                  [        U5      5      PM     nnOOU R                   Vs/ s H  oAR                  [        U5      5      PM     nnU R                   Vs/ s H  nSPM     nn[        S [        XVU5       5       5      $ s  snf s  snf s  snf s  snf s  snf )Nr   rr   Tc              3   h   #    U  H(  u  pn[        X-  U4[        R                  S 45      v   M*     g7f)TN)r   r   r   )rE   r   rw   blvs       r/   rH   3FinitePSpace.compute_expectation.<locals>.<genexpr>=  s5      H'FOD dk3/!&&$@@'Fs   02)r   r%   r   r   rf   r   r   r   r   r4   r  zip)r-   r   rvskwargsrw   probsparse_domainboolss           r/   compute_expectation FinitePSpace.compute_expectation3  s    T[[t!04<d#<dUJ/00:>++F+$E$KN1-+LF;?;;G;4]]4:.;EGEBF++N+$MM$t*5+LN&*kk2kdTkE2 H'*5'FH H 	H =FGN2s   D04D5#D:#D?Ec                     U R                  U5      n[        SSS9n[        US:  US:  -  44nUR                  5        H  u  pVXEX6:*  44-   nM     [	        U[        U6 5      $ )NpTr  r   rr   )r   r   r
   r   r   r   )r-   r   r   r  rj   r   values          r/   compute_quantileFinitePSpace.compute_quantile@  sm    t$#D!a!eA&')))+JCqz*--C &aC))r2   c                 x  ^ ^^ [        S [        T5       5       5      n[        T5      nUR                  T R                  5      (       d$  [        S[        UT R                  -
  5      -  5      e[        T[        5      (       a  UR                  R                  T R                  R                  5      (       dX  [        TR                  [        5      (       a  TR                  OTR                  m[        UUU 4S jT R                   5       5      $ [        [        U 4S jT R!                  T5       5       5      5      $ )Nc              3   8   #    U  H  oR                   v   M     g 7frD   )ri   )rE   rss     r/   rH   +FinitePSpace.probability.<locals>.<genexpr>I  s      O5Nr5Nr   z)Cannot compare foreign random symbols, %sc           
   3      >#    U  HQ  n[        TR                  U5      TR                  T[        U5      S    S   5      4[        R
                  S45      v   MS     g7f)r   rr   TN)r   r   subsr   r   r   )rE   rw   r   rvr-   s     r/   rH   r$  Q  sW      @3>4 !T*INN2tDz!}Q?O,PQ~' '3>s   AAc              3   F   >#    U  H  nTR                  U5      v   M     g 7frD   )r   r{   s     r/   rH   r$  T  s     P:O$4<<--:Os   !)ru   r#   r%   issubsetrK   r   r   rf   r   free_symbolsr   r   r   r   r  r   r   )r-   r   cond_symbolsr   r'  s   ``  @r/   probabilityFinitePSpace.probabilityH  s      O^I5N OOy!$$T\\22H"<$,,#>?A B Bi,,""++DKK,D,DEE",Y]]F"C"CB @37;;@ @ @ sP$**Y:OPPQQr2   c                     U R                  U5      nU R                  U5      nU R                  R                  5        VVs0 s H"  u  pEUR	                  U5      (       d  M  XEU-  _M$     nnn[        X&5      $ s  snnf rD   )r   r,  r   r   r   r   r-   r   r   r   r   rG   r   s          r/   conditional_spaceFinitePSpace.conditional_spaceV  su    I&	* $ 3 3 5L 5HCc9J #3d
? 5 	 LF,,Ls    A7 	A7r7   c                 R    U R                   U R                  R                  XU5      0$ )zW
Internal sample method

Returns dictionary mapping RandomSymbol to realization value.
)r  distributionsample)r-   sizelibraryseeds       r/   r4  FinitePSpace.sample]  s&     

D--44TDIJJr2   )FrD   )r7   scipyN)r8   r9   r:   r;   r<   ra   rg   r   r   r   r   r   r   r	  r  r  r  r,  r0  r4  r>   r7   r2   r/   r   r      s    
 I6? 	 	   A A ? ?H*R-Kr2   r   c                       \ rS rSrSr\S 5       r\S 5       r\S 5       rS r	\\
S 5       5       r\
S 5       r\
S	 5       rS
 rS rS rSS jrS rS rSrg)SingleFinitePSpaceif  z
A single finite probability space

Represents the probabilities of a set of random events that can be
attributed to a single variable/symbol.

This class is implemented by many of the standard FiniteRV types such as
Die, Bernoulli, Coin, etc....
c                 V    [        U R                  U R                  R                  5      $ rD   )rc   ri   r3  rj   r5   s    r/   r   SingleFinitePSpace.domainp  s    !$++t/@/@/D/DEEr2   c                 .    U R                   R                  $ )zc
Helper property to check if the distribution
of the random variable is having symbolic
dimension.
)r3  r   r5   s    r/   _is_symbolicSingleFinitePSpace._is_symbolict  s       ,,,r2   c                      U R                   S   $ rq   rO   r5   s    r/   r3  SingleFinitePSpace.distribution}  rR   r2   c                 8    U R                   R                  U5      $ rD   )r3  r   r-   r   s     r/   r   SingleFinitePSpace.pmf  s      $$T**r2   c                     U R                   R                  R                  5        VVs0 s H  u  p[        U R                  U45      U_M     snn$ s  snnf rD   )r3  r4   r   r   ri   )r-   rG   r   s      r/   r   SingleFinitePSpace._density  sW     &*%6%6%;%;%A%A%CE%C	 4;;,-t3%CE 	E Es   $Ac           
         U R                   (       a  U R                  U5      n[        SSS9n[        S5      n[        U[	        U" U5      [        [        U-  U-  5      -  X@R                  S   R                  U R                  S   R                  45      5      $ [        XR                  5      n[        U R                  U R                  5      R                  U5      $ Nr   Tr  kirr   )r?  r   r   r   r   r   r	   rP   lowhighr%   r   r   r   r3  r	  r-   r   r   r   rJ  s        r/   r	  2SingleFinitePSpace.compute_characteristic_function  s    $$T*Ac%AtB!S2s1R46{!2R19I9I499UV<K\K\4]^__t[[)DKK):):;[[\`aar2   c           
         U R                   (       a  U R                  U5      n[        SSS9n[        S5      n[        U[	        U" U5      [        XC-  5      -  X@R                  S   R                  U R                  S   R                  45      5      $ [        XR                  5      n[        U R                  U R                  5      R                  U5      $ rI  )r?  r   r   r   r   r   rP   rK  rL  r%   r   r   r   r3  r  rM  s        r/   r  5SingleFinitePSpace.compute_moment_generating_function  s    $$T*Ac%AtB!S2s24y2yy|7G7GSTIZIZ2[\]]t[[)DKK):):;^^_cddr2   c                     U R                   (       a  [        S5      e[        XR                  5      n[	        U R
                  U R                  5      R                  U5      $ )NzComputing quantile for random variables with symbolic dimension because the bounds of searching the required value is undetermined.)r?  r   r%   r   r   r   r3  r  rD  s     r/   r  #SingleFinitePSpace.compute_quantile  sO    % '% & & t[[)DKK):):;LLTRRr2   c                 2   U R                   (       a  [        [        U5      5      S   n[        SSS9n[	        U[
        [        45      (       d  SOUR                  X#5      n[        U[        U R                  U5      [        X0R                  S   R                  :  X0R                  S   R                  :*  U5      4[        R                   S45      5      $ [#        XR$                  5      n['        U R(                  U R*                  5      R-                  U5      $ )Nr   r   Tintegerrr   )r?  r   r#   r   rf   r   r   r&  r   r   r   r   rP   rK  rL  r   r   r%   r   r   r   r3  r   )r-   r   r'  r   r   s        r/   r   "SingleFinitePSpace.compute_density  s    nT*+A.Bc4(A)$U0CDD4))B* !txx{CYYq\-=-=(=1"""D%* +-.VVTN<= = t[[)DKK):):;KKDQQr2   c           	      d   U R                   (       a\  U R                  U5      n[        S5      n[        S5      n[        U[	        U" U5      X@R
                  S   R                  U45      5      $ [        XR                  5      n[        U R                  U R                  5      R                  U5      $ )Nr   rJ  rr   )r?  r   r   r   r   rP   rK  r%   r   r   r   r3  r   )r-   r   r   r   rJ  s        r/   r   SingleFinitePSpace.compute_cdf  s    $$T*Ac
AtB!S2YYq\-=-=q(ABCCt[[)DKK):):;GGMMr2   Nc                 \   U R                   (       a  [        U5      S   n[        SSS9nUR                  XE5      n[	        U[
        [        45      (       d  SOUnUS:w  a  U R                  U5      U-  OU R                  U5      U-  n[        [        Xv4[        R                  S45      XPR                  R                  U R                  R                  45      R                  5       $ [!        U5      n[#        X5      n[%        U R&                  U R                  5      R(                  " X40 UD6$ )Nr   r   TrT  )r?  r#   r   r&  rf   r   r   r   r   r   r   r   r3  rK  rL  doitr   r%   r   r   r  )r-   r   r  r  r'  r   r   funcs           r/   r  &SingleFinitePSpace.compute_expectation  s    %a(Bc4(A99R#D)$U0CDD4 &*dl488A;?d8JDy$~>%%))4+<+<+A+ABDDHDFK ~t!DKK):):;OOPTd]cddr2   c                     U R                   (       a  [        S5      e[        U5      n[        U R                  U R
                  5      R                  U5      $ )NzhCurrently, probability queries are not supported for random variables with symbolic sized distributions.)r?  r   r%   r   r   r3  r,  r   s     r/   r,  SingleFinitePSpace.probability  sL    % 'P Q QI&	DKK):):;GG	RRr2   c                     U R                   (       a  U   U R                  U5      nU R                  U5      nU R                  R	                  5        VVs0 s H"  u  pEUR                  U5      (       d  M  XEU-  _M$     nnn[        X&5      $ s  snnf )z
This method is used for transferring the
computation to probability method because
conditional space of random variables with
symbolic dimensions is currently not possible.
)r?  r   r,  r   r   r   r   r/  s          r/   r0  $SingleFinitePSpace.conditional_space  s     I&	* $ 3 3 5L 5HCc9J #3d
? 5 	 LF,,Ls   B
3	B
r7   rD   )r8   r9   r:   r;   r<   r=   r   r?  r3  r   r   r   r	  r  r  r   r   r  r,  r0  r>   r7   r2   r/   r;  r;  f  s     F F - -  + E  E b b e eS
RNeS-r2   r;  c                   h    \ rS rSrSr\S 5       r\\S 5       5       r\\S 5       5       r	S r
S rSrg	)
ProductFinitePSpacei  z?
A collection of several independent finite probability spaces
c                 d    [        U R                   Vs/ s H  oR                  PM     sn6 $ s  snf rD   )r   spacesr   )r-   spaces     r/   r   ProductFinitePSpace.domain  s%    "t{{$K{e\\{$KLL$Ks   -c           	      V   [        U R                   Vs/ s H&  n[        UR                  R	                  5       5      PM(     sn6 n0 nU HN  n[        [        U6 5      u  pV[        U5      n[        U6 nUR                  U[        R                  5      U-   X7'   MP     [        U5      $ s  snf rD   )r   rd  iterr   r   r   r  r$   r   r   r   r   r   )	r-   re  r   r   r   elemsr  rw   r   s	            r/   r   ProductFinitePSpace._density  s     &$ "%.."6"6"89$& 'EU,LE5>D;DeeD!&&)D0AG	 
 Aw&s   -B&c                 ,    [        U R                  5      $ rD   )r   r   r5   s    r/   r   ProductFinitePSpace.density  s     DMM""r2   c                 ,    [         R                  X5      $ rD   )r   r,  r   s     r/   r,  ProductFinitePSpace.probability  s    ''88r2   c                 ,    [         R                  X5      $ rD   )r   r   rD  s     r/   r   #ProductFinitePSpace.compute_density  s    ++D77r2   r7   N)r8   r9   r:   r;   r<   r=   r   r   r   r   r,  r   r>   r7   r2   r/   rb  rb    s_     M M 	  	 #  #98r2   rb  N)@r<   	itertoolsr   sympy.concrete.summationsr   sympy.core.basicr   sympy.core.cacher   sympy.core.functionr   sympy.core.mulr   sympy.core.numbersr	   r
   sympy.core.relationalr   sympy.core.singletonr   sympy.core.symbolr   r   sympy.core.sympifyr   &sympy.functions.elementary.exponentialr   $sympy.functions.elementary.piecewiser   sympy.logic.boolalgr   r   sympy.sets.setsr   sympy.core.containersr   sympy.core.logicr   r   r   r   sympy.stats.rvr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r4   r*   r@   rc   r   r   r   r   r;  rb  r7   r2   r/   <module>r     s     ) " $ &  ' $ " - & 6 : ) ( & " , ' %U U U U
D 2Q< Q<"6 "6J -   .-/1D .-b!!|^ !!RyK6 yKxy-| y-x82L 8r2   