
    EdA                     D   d 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 ddlmZmZ dd	l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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( ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5  G d de6          Z7 G d de*          Z8 G d de8          Z9 G d de+e8          Z: G d d e,e:          Z; G d! d"e5e3          Z< G d# d$e-          Z= G d% d&e/e=          Z> G d' d(e.e=          Z?d)S )*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                   .    e Zd ZdZd Zed             ZdS )FiniteDensityz'
    A domain with Finite Density.
    c                 <    t          |          }|| v r| |         S dS )z
        Make instance of a class callable.

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

        Otherwise, return 0.
        r   r   )selfitems     /lib/python3.11/site-packages/sympy/stats/frv.py__call__zFiniteDensity.__call__(   s*     t}}4< 	:1    c                      t          |           S )z,
        Return item as dictionary.
        )dictr-   s    r/   r3   zFiniteDensity.dict6   s    
 Dzzr1   N)__name__
__module____qualname____doc__r0   propertyr3    r1   r/   r+   r+   $   sH              X  r1   r+   c                   j    e Zd ZdZdZed             Zed             Zed             Zd Z	d Z
d Zd	S )
FiniteDomainzS
    A domain with discrete finite support

    Represented using a FiniteSet.
    Tc                 >    t          d | j        D                       S )Nc              3       K   | ]	\  }}|V  
d S Nr:   .0symvals      r/   	<genexpr>z'FiniteDomain.symbols.<locals>.<genexpr>G   s&      ;;c;;;;;;r1   r   elementsr4   s    r/   symbolszFiniteDomain.symbolsE   s!    ;;T];;;;;;r1   c                     | j         d         S Nr   argsr4   s    r/   rF   zFiniteDomain.elementsI       y|r1   c                 2    t          d | j        D              S )Nc                 F    g | ]}t          t          |                    S r:   )r   r3   )rA   els     r/   
<listcomp>z%FiniteDomain.dict.<locals>.<listcomp>O   s$    BBBb4R>>BBBr1   rE   r4   s    r/   r3   zFiniteDomain.dictM   s    BBDMBBBCCr1   c                     || j         v S r?   )rF   r-   others     r/   __contains__zFiniteDomain.__contains__Q   s    %%r1   c                 4    | j                                         S r?   )rF   __iter__r4   s    r/   rV   zFiniteDomain.__iter__T   s    }%%'''r1   c                 (    t          d | D              S )Nc                 4    g | ]}t          d  |D              S )c                 4    g | ]\  }}t          ||          S r:   r   r@   s      r/   rP   z6FiniteDomain.as_boolean.<locals>.<listcomp>.<listcomp>X   s$    <<<83"S#,,<<<r1   )r   )rA   r.   s     r/   rP   z+FiniteDomain.as_boolean.<locals>.<listcomp>X   s,    OOO$C<<t<<<=OOOr1   )r   r4   s    r/   
as_booleanzFiniteDomain.as_booleanW   s    OO$OOOPPr1   N)r5   r6   r7   r8   	is_Finiter9   rG   rF   r3   rT   rV   rZ   r:   r1   r/   r<   r<   =   s         
 I< < X<   X D D XD& & &( ( (Q Q Q Q Qr1   r<   c                   |    e Zd ZdZd Zed             Zed             Zed             Zed             Z	d Z
d Zd	S )
SingleFiniteDomainzi
    A FiniteDomain over a single symbol/set

    Example: The possibilities of a *single* die roll.
    c                     t          |t                    st          |t                    s	t          | }t          j        | ||          S r?   )
isinstancer   r   r   __new__)clssymbolsets      r/   r`   zSingleFiniteDomain.__new__b   sC    #y)) 	"3--	"S/C}S&#...r1   c                     | j         d         S rI   rJ   r4   s    r/   rb   zSingleFiniteDomain.symbolh   rL   r1   c                 *    t          | j                  S r?   r   rb   r4   s    r/   rG   zSingleFiniteDomain.symbolsl   s    %%%r1   c                     | j         d         S N   rJ   r4   s    r/   rc   zSingleFiniteDomain.setp   rL   r1   c                 8     t           fd j        D              S )Nc                 >    g | ]}t          j        |ff          S r:   	frozensetrb   rA   elemr-   s     r/   rP   z/SingleFiniteDomain.elements.<locals>.<listcomp>v   s+    SSS$9t{D&9%<==SSSr1   )r   rc   r4   s   `r/   rF   zSingleFiniteDomain.elementst   s%    SSSS$(SSSTTr1   c                 *      fd j         D             S )Nc              3   F   K   | ]}t          j        |ff          V  d S r?   rl   rn   s     r/   rD   z.SingleFiniteDomain.__iter__.<locals>.<genexpr>y   s5      GGd	DK.011GGGGGGr1   rc   r4   s   `r/   rV   zSingleFiniteDomain.__iter__x   s    GGGGdhGGGGr1   c                 Z    t          |          d         \  }}|| j        k    o|| j        v S rI   )tuplerb   rc   )r-   rS   rB   rC   s       r/   rT   zSingleFiniteDomain.__contains__{   s-    <<?Sdk!5cTXo5r1   N)r5   r6   r7   r8   r`   r9   rb   rG   rc   rF   rV   rT   r:   r1   r/   r]   r]   [   s         / / /   X & & X&   X U U XUH H H6 6 6 6 6r1   r]   c                   .    e Zd ZdZd Zed             ZdS )ProductFiniteDomainz
    A Finite domain consisting of several other FiniteDomains

    Example: The possibilities of the rolls of three independent dice
    c                 6    t          | j         }d |D             S )Nc              3   4   K   | ]}t          |          V  d S r?   )r%   )rA   itemss     r/   rD   z/ProductFiniteDomain.__iter__.<locals>.<genexpr>   s(      555555555r1   )r   domains)r-   proditers     r/   rV   zProductFiniteDomain.__iter__   s"    DL)55H5555r1   c                     t          |  S r?   r   r4   s    r/   rF   zProductFiniteDomain.elements   s    $r1   N)r5   r6   r7   r8   rV   r9   rF   r:   r1   r/   rv   rv      sH         6 6 6     X     r1   rv   c                   F    e Zd ZdZd Zd Zd Zd Zed             Z	d Z
dS )	ConditionalFiniteDomainz
    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                 X    |du r|S t          |          }t          j        | ||          S )zH
        Create a new instance of ConditionalFiniteDomain class
        T)r&   r   r`   )ra   domain	conditionconds       r/   r`   zConditionalFiniteDomain.__new__   s7      	My!!}S&$///r1   c                     | j                             t          |                    }|dv r|S |j        r|j        |j        k    S t          dt          |          z            )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   xreplacer3   is_Equalitylhsrhs
ValueErrorstr)r-   ro   rC   s      r/   _testzConditionalFiniteDomain._test   sd     n%%d4jj11- 	&J_ 	&7cg%%,s3xx7888r1   c                 >    || j         v o|                     |          S r?   )
fulldomainr   rR   s     r/   rT   z$ConditionalFiniteDomain.__contains__   s     '=DJJu,=,==r1   c                 *      fd j         D             S )Nc              3   F   K   | ]}                     |          |V  d S r?   r   rn   s     r/   rD   z3ConditionalFiniteDomain.__iter__.<locals>.<genexpr>   s4      EEDJJt4D4DEEEEEEEr1   )r   r4   s   `r/   rV   z ConditionalFiniteDomain.__iter__   s    EEEEEEEEr1   c                      t           j        t                    rt           fd j        j        D              S t          d          )Nc                 P    g | ]"}t          j        j        |ff          v  |#S r:   )rm   r   rb   rn   s     r/   rP   z/ConditionalFiniteDomain.set.<locals>.<listcomp>   sO     X X X"+do.Dd-K,M"N"NRV"VXt X X Xr1   z7Not implemented on multi-dimensional conditional domain)r_   r   r]   r   rc   NotImplementedErrorr4   s   `r/   rc   zConditionalFiniteDomain.set   ss    do'9:: 	K X X X X0C X X X Y Y &IK K Kr1   c                 6    t                               |           S r?   )r<   rZ   r4   s    r/   rZ   z"ConditionalFiniteDomain.as_boolean   s    &&t,,,r1   N)r5   r6   r7   r8   r`   r   rT   rV   r9   rc   rZ   r:   r1   r/   r~   r~      s         0 0 09 9 9> > >F F F K K XK- - - - -r1   r~   c                       e Zd Zd Zed             Zeed                         Zd Z	ed             Z
 ed           Z ed           Z ed           Z ed	           Z ed
           Zd Zd ZdS )SingleFiniteDistributionc                 j    t          t          t          |                    }t          j        | g|R  S r?   )listmapr   r   r`   )ra   rK   s     r/   r`   z SingleFiniteDistribution.__new__   s1    C&&''}S(4((((r1   c                      d S r?   r:   rJ   s    r/   checkzSingleFiniteDistribution.check   s    r1   c                 V      j         rt                     S  fd j        D             S )Nc                 <    i | ]}|                     |          S r:   pmf)rA   kr-   s     r/   
<dictcomp>z1SingleFiniteDistribution.dict.<locals>.<dictcomp>   s%    1111488A;;111r1   )is_symbolicr(   rc   r4   s   `r/   r3   zSingleFiniteDistribution.dict   s8      	!4== 11111111r1   c                     t                      r?   r   r-   rK   s     r/   r   zSingleFiniteDistribution.pmf   s    !###r1   c                     t                      r?   r   r4   s    r/   rc   zSingleFiniteDistribution.set   s    !###r1   c                     | j         j        S r?   )r3   valuesr4   s    r/   <lambda>z!SingleFiniteDistribution.<lambda>   s    49#3 r1   c                     | j         j        S r?   )r3   ry   r4   s    r/   r   z!SingleFiniteDistribution.<lambda>   s
    $)/ r1   c                     dS )NFr:   r4   s    r/   r   z!SingleFiniteDistribution.<lambda>   s     r1   c                     | j         j        S r?   )r3   rV   r4   s    r/   r   z!SingleFiniteDistribution.<lambda>   s    TY%7 r1   c                     | j         j        S r?   )r3   __getitem__r4   s    r/   r   z!SingleFiniteDistribution.<lambda>   s    	(= r1   c                      | j         | S r?   r   r   s     r/   r0   z!SingleFiniteDistribution.__call__   s    txr1   c                     || j         v S r?   rr   rR   s     r/   rT   z%SingleFiniteDistribution.__contains__   s      r1   N)r5   r6   r7   r`   staticmethodr   r9   r   r3   r   rc   r   ry   r   rV   r   r0   rT   r:   r1   r/   r   r      s       ) ) )   \ 2 2 W X2
$ $ $ $ $ X$ X3344FH1122E(--..Kx7788H(==>>K  ! ! ! ! !r1   r   c                       e Zd ZdZdZd Zd Zd Zd Ze	d             Z
e	dd	            Ze	d
             Ze	d             ZddZd Zd Zd ZddZdS )FinitePSpacezd
    A Finite Probability Space

    Represents the probabilities of a finite number of events.
    Tc                     d |                                 D             }t          |          }t          j        | ||          }||_        |S )Nc                 N    i | ]"\  }}t          |          t          |          #S r:   r   )rA   keyrC   s      r/   r   z(FinitePSpace.__new__.<locals>.<dictcomp>   s:     1 1 1C 3<< 1 1 1r1   )ry   r   r!   r`   _density)ra   r   densitypublic_densityobjs        r/   r`   zFinitePSpace.__new__   sR    1 1 '1 1 1gnS&.99
r1   c                 T   t          |          }| j        }t          t          |                                          d         t
                    r |                    |t          j                  S |                    t          |          d         d         t          j                  S )Nr   ri   )
r   r   r_   r   keysr   getr   Zerort   )r-   ro   r   s      r/   prob_ofzFinitePSpace.prob_of   sv    t}}-d7<<>>**1-y99 	-;;tQV,,,{{5;;q>!,af555r1   c                      t           fdt          |          D                       sJ t           j        |          S )Nc              3   4   K   | ]}|j         j        v V  d S r?   )rb   rG   )rA   rr-   s     r/   rD   z%FinitePSpace.where.<locals>.<genexpr>  s,      OO18t|+OOOOOOr1   )allr$   r~   r   r-   r   s   ` r/   wherezFinitePSpace.where  sF    OOOO^I5N5NOOOOOOOO&t{I>>>r1   c                    t          || j                  }t                      }| j        D ]_}|                    t          |                    }|                     |          }|                    |t          j	                  |z   ||<   `|S r?   )
r&   r   r+   r   r   r3   r   r   r   r   )r-   exprdro   rC   probs         r/   compute_densityzFinitePSpace.compute_density  sz    tT[))OOK 	/ 	/D--T

++C<<%%DUU3''$.AcFFr1   c                     |                      |          }t          j        }g }t          |          D ]&}||         }||z  }|                    ||f           't          |          S r?   )r   r   r   sortedappendr3   )r-   r   r   cum_probcdfr   r   s          r/   compute_cdfzFinitePSpace.compute_cdf  sn      &&6!99 	( 	(CS6DHJJX''''Cyyr1   Fc                     |                      |          }t          |                                          }t          |d           }|rd |D             }|S )Nc                     | d         S rh   r:   )val_cumprobs    r/   r   z)FinitePSpace.sorted_cdf.<locals>.<lambda>  s
    [^ r1   )r   c                 6    g | ]\  }}|t          |          fS r:   )float)rA   vr   s      r/   rP   z+FinitePSpace.sorted_cdf.<locals>.<listcomp>!  s7     5 5 5#8 h0 5 5 5r1   )r   r   ry   r   )r-   r   python_floatr   ry   sorted_itemss         r/   
sorted_cdfzFinitePSpace.sorted_cdf  sl    t$$SYY[[!!e)K)KLLL 	55 5'35 5 5Lr1   c                     |                      |          }t          dd          t          t          fd|                                D                                 S )NtTrealc              3   X   K   | ]$\  }}t          t          |z  z            |z  V  %d S r?   )r   r	   rA   r   r   r   s      r/   rD   z?FinitePSpace.compute_characteristic_function.<locals>.<genexpr>*  s9      ??caS1QZZ\??????r1   r   r   r   sumry   r-   r   r   r   s      @r/   compute_characteristic_functionz,FinitePSpace.compute_characteristic_function%  s]      &&#D!!!a????QWWYY?????@@@r1   c                     |                      |          }t          dd          t          t          fd|                                D                                 S )Nr   Tr   c              3   H   K   | ]\  }}t          |z            |z  V  d S r?   r   r   s      r/   rD   zBFinitePSpace.compute_moment_generating_function.<locals>.<genexpr>1  s5      ==CAaS1XXaZ======r1   r   r   s      @r/   "compute_moment_generating_functionz/FinitePSpace.compute_moment_generating_function,  s]      &&#D!!!a====17799=====>>>r1   Nc                 x    |p j         }t          |           fd j        D             }t          t          t
          f          r%d  j        D             }fd j        D             }n$fd j        D             }d  j        D             }t          d t          |||          D                       S )Nc                 :    g | ]}                     |          S r:   r   rn   s     r/   rP   z4FinitePSpace.compute_expectation.<locals>.<listcomp>6  s%    <<<d##<<<r1   c                 D    g | ]}t          |          d          d         S )r   ri   )rt   rA   ro   s     r/   rP   z4FinitePSpace.compute_expectation.<locals>.<listcomp>8  s'    FFF$E$KKN1-FFFr1   c                 T    g | ]$}                     t          |                    %S r:   r   r3   rA   ro   r   s     r/   rP   z4FinitePSpace.compute_expectation.<locals>.<listcomp>9  s+    GGG4T]]4::..GGGr1   c                 T    g | ]$}                     t          |                    %S r:   r   r   s     r/   rP   z4FinitePSpace.compute_expectation.<locals>.<listcomp>;  s+    NNN$DMM$t**55NNNr1   c                     g | ]}d S Tr:   r   s     r/   rP   z4FinitePSpace.compute_expectation.<locals>.<listcomp><  s    222dT222r1   c                 X    g | ]'\  }}}t          ||z  |ft          j        d f          (S r   )r   r   r   )rA   r   ro   blvs       r/   rP   z4FinitePSpace.compute_expectation.<locals>.<listcomp>=  sM     H H H#D$ td{C0164.AA H H Hr1   )r   r&   r   r_   r   r   r   zip)r-   r   rvskwargsprobsparse_domainboolss   ``     r/   compute_expectationz FinitePSpace.compute_expectation3  s     T[tS!!<<<<<<<dUJ/00 	3FF$+FFFLGGGG4;GGGEENNNN$+NNNL22dk222E H H'*5,'F'FH H H I I 	Ir1   c                     |                      |          }t          dd          }t          |dk     |dk    z  ff}|                                D ]\  }}||||k    ffz   }t	          |t          |           S )NpTr   r   ri   )r   r   r
   ry   r   r   )r-   r   r   r   rc   r   values          r/   compute_quantilezFinitePSpace.compute_quantile@  s    t$$#D!!!a!eA&')))++ 	. 	.JC#qEz*--CCaC)))r1   c                 p    t          d t                    D                       }t                    }|                     j                  s't          dt          | j        z
            z            t          t                    rn|j	                             j
        j	                  sJt          j        t                    rj        nj        t           fd j
        D                       S t          t           fd                               D                                 S )Nc              3   $   K   | ]}|j         V  d S r?   )rb   )rA   rss     r/   rD   z+FinitePSpace.probability.<locals>.<genexpr>I  s$       O Or O O O O O Or1   z)Cannot compare foreign random symbols, %sc           
   3      K   | ]b}t                              |                              t          |          d          d                   ft          j        df          V  cdS )r   ri   TN)r   r   subsr   r   r   )rA   ro   r   rvr-   s     r/   rD   z+FinitePSpace.probability.<locals>.<genexpr>Q  s       @ @+/ !T**INN2tDzz!}Q?O,P,PQ~' ' @ @ @ @ @ @r1   c              3   B   K   | ]}                     |          V  d S r?   r   rn   s     r/   rD   z+FinitePSpace.probability.<locals>.<genexpr>T  s/      PP$4<<--PPPPPPr1   )rm   r$   r&   issubsetrG   r   r   r_   r   free_symbolsr   r   r   r   r   r   r   )r-   r   cond_symbolsr   r  s   ``  @r/   probabilityzFinitePSpace.probabilityH  sX     O O^I5N5N O O OOOy!!$$T\22 	BH"<$,#>??A B B Bi,, 	@"++DK,DEE	@",Y]F"C"CVB @ @ @ @ @ @37;@ @ @ @ @ @ sPPPP$**Y:O:OPPPPPQQQr1   c                     |                      |          |                     |          fd| j                                        D             }t	          |          S )Nc                 L    i | ] \  }}                     |          ||z  !S r:   r   rA   r   rC   r   r   s      r/   r   z2FinitePSpace.conditional_space.<locals>.<dictcomp>Y  J     L L LCc9J9JL3d
 L L Lr1   )r   r  r   ry   r   r-   r   r   r   r   s      @@r/   conditional_spacezFinitePSpace.conditional_spaceV  s{    I&&	**L L L L L $ 3 3 5 5L L LFG,,,r1   r:   scipyc                 H    | j         | j                            |||          iS )zo
        Internal sample method

        Returns dictionary mapping RandomSymbol to realization value.
        )r   distributionsample)r-   sizelibraryseeds       r/   r  zFinitePSpace.sample]  s&     
D-44T7DIIJJr1   )Fr?   )r:   r  N)r5   r6   r7   r8   r[   r`   r   r   r   r   r   r   r   r   r   r   r  r  r  r:   r1   r/   r   r      s7        
 I  6 6 6? ? ?   	 	 W	    W A A WA ? ? W?I I I I* * *R R R- - -K K K K K Kr1   r   c                       e Zd ZdZed             Zed             Zed             Zd Zee	d                         Z
e	d             Ze	d             Zd	 Zd
 Zd ZddZd Zd ZdS )SingleFinitePSpacea  
    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                 @    t          | j        | j        j                  S r?   )r]   rb   r  rc   r4   s    r/   r   zSingleFinitePSpace.domainp  s    !$+t/@/DEEEr1   c                     | j         j        S )z
        Helper property to check if the distribution
        of the random variable is having symbolic
        dimension.
        )r  r   r4   s    r/   _is_symboliczSingleFinitePSpace._is_symbolict  s      ,,r1   c                     | j         d         S rh   rJ   r4   s    r/   r  zSingleFinitePSpace.distribution}  rL   r1   c                 6    | j                             |          S r?   )r  r   r-   r   s     r/   r   zSingleFinitePSpace.pmf  s     $$T***r1   c                 X      fd j         j                                        D             S )Nc                 D    i | ]\  }}t          j        |f          |S r:   rf   )rA   rC   r   r-   s      r/   r   z/SingleFinitePSpace._density.<locals>.<dictcomp>  sD     E E E!T 4;,--t E E Er1   )r  r3   ry   r4   s   `r/   r   zSingleFinitePSpace._density  sH    E E E E%)%6%;%A%A%C%CE E E 	Er1   c           
         | j         r|                     |          }t          dd          }t          d          }t          |t	           ||          t          t          |z  |z            z  || j        d         j        | j        d         j	        f                    S t          || j                  }t          | j        | j                                      |          S Nr   Tr   kiri   )r  r   r   r   r   r   r	   rK   lowhighr&   r   r   r   r  r   r-   r   r   r   r"  s        r/   r   z2SingleFinitePSpace.compute_characteristic_function  s     	`$$T**Ac%%%AtB!S2s1R46{{!2R19I49UV<K\4]^^___tT[))DK):;;[[\`aaar1   c           
         | j         r|                     |          }t          dd          }t          d          }t          |t	           ||          t          ||z            z  || j        d         j        | j        d         j        f                    S t          || j
                  }t          | j        | j                                      |          S r!  )r  r   r   r   r   r   rK   r#  r$  r&   r   r   r   r  r   r%  s        r/   r   z5SingleFinitePSpace.compute_moment_generating_function  s     	^$$T**Ac%%%AtB!S2s2a4yy2ty|7GSTIZ2[\\]]]tT[))DK):;;^^_cdddr1   c                     | j         rt          d          t          || j                  }t	          | j        | j                                      |          S )NzComputing quantile for random variables with symbolic dimension because the bounds of searching the required value is undetermined.)r  r   r&   r   r   r   r  r   r  s     r/   r   z#SingleFinitePSpace.compute_quantile  sZ     	&% '% & & & tT[))DK):;;LLTRRRr1   c                 N   | j         rt          t          |                    d         }t          dd          }t	          |t
          t          f          sdn|                    ||          }t          |t          | 
                    |          t          || j        d         j        k    || j        d         j        k    |          ft          j        df                    S t#          || j                  }t'          | j        | j                                      |          S )Nr   r   Tintegerri   )r  r   r$   r   r_   r   r   r  r   r   r   r   rK   r#  r$  r   r   r&   r   r   r   r  r   )r-   r   r  r   r   s        r/   r   z"SingleFinitePSpace.compute_density  s
    	=nT**++A.Bc4(((A)$U0CDD +44))B** !txx{{CTYq\-=(=1""D%* %* +-.VTN< <= = = tT[))DK):;;KKDQQQr1   c           	      n   | j         rm|                     |          }t          d          }t          d          }t          |t	           ||          || j        d         j        |f                    S t          || j                  }t          | j
        | j                                      |          S )Nr   r"  ri   )r  r   r   r   r   rK   r#  r&   r   r   r   r  r   )r-   r   r   r   r"  s        r/   r   zSingleFinitePSpace.compute_cdf  s     	D$$T**Ac

AtB!S2TYq\-=q(ABBCCCtT[))DK):;;GGMMMr1   Nc                 j   | j         rt          |          d         }t          dd          }|                    ||          }t	          |t
          t          f          sdn|}|dk    r|                     |          |z  n|                     |          |z  }t          t          ||ft          j        df          || j        j        | j        j        f                                          S t!          |          }t#          ||          } t%          | j        | j                  j        ||fi |S )Nr   r   Tr)  )r  r$   r   r  r_   r   r   r   r   r   r   r   r  r#  r$  doitr   r&   r   r   r   )r-   r   r   r   r  r   r   funcs           r/   r   z&SingleFinitePSpace.compute_expectation  s,    	K%%a(Bc4(((A99R##D)$U0CDD 44 &*dlJ488A;;??d8JDy$~>>D%)4+<+ABD DDHDFFK ~~tS!!O|DK):;;OPTVYdd]cdddr1   c                     | j         rt          d          t          |          }t          | j        | j                                      |          S )NzhCurrently, probability queries are not supported for random variables with symbolic sized distributions.)r  r   r&   r   r   r  r  r   s     r/   r  zSingleFinitePSpace.probability  sY     	Q% 'P Q Q QI&&	DK):;;GG	RRRr1   c                     | j         r|  |                     |          |                     |          fd| j                                        D             }t          |          S )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.
        c                 L    i | ] \  }}                     |          ||z  !S r:   r   r  s      r/   r   z8SingleFinitePSpace.conditional_space.<locals>.<dictcomp>  r  r1   )r  r   r  r   ry   r   r  s      @@r/   r  z$SingleFinitePSpace.conditional_space  s      	DI&&	**L L L L L $ 3 3 5 5L L LFG,,,r1   r?   )r5   r6   r7   r8   r9   r   r  r  r   r   r   r   r   r   r   r   r   r  r  r:   r1   r/   r  r  f  sT         F F XF - - X-   X+ + + E E W XE b b Wb e e WeS S S
R 
R 
RN N Ne e e eS S S- - - - -r1   r  c                       e Zd ZdZed             Zeed                         Zeed                         Zd Z	d Z
dS )ProductFinitePSpacezG
    A collection of several independent finite probability spaces
    c                 2    t          d | j        D              S )Nc                     g | ]	}|j         
S r:   )r   rA   spaces     r/   rP   z.ProductFinitePSpace.domain.<locals>.<listcomp>  s    $K$K$KeU\$K$K$Kr1   )rv   spacesr4   s    r/   r   zProductFinitePSpace.domain  s    "$K$Kt{$K$K$KLLr1   c                    t          d | j        D              }i }|D ]Y}t          t          |           \  }}t	          |          }t          | }|                    |t          j                  |z   ||<   Zt          |          S )Nc                 Z    g | ](}t          |j                                                  )S r:   )iterr   ry   r6  s     r/   rP   z0ProductFinitePSpace._density.<locals>.<listcomp>  s>     & & & "%."6"6"8"899 & & &r1   )
r   r8  r   r   r%   r   r   r   r   r   )r-   r{   r   ry   elemsr   ro   r   s           r/   r   zProductFinitePSpace._density  s      & && & & ' 	1 	1EU,,LE55>>D;DeeD!&))D0AdGGAwwr1   c                 *    t          | j                  S r?   )r   r   r4   s    r/   r   zProductFinitePSpace.density  s     DM"""r1   c                 8    t                               | |          S r?   )r   r  r   s     r/   r  zProductFinitePSpace.probability  s    ''i888r1   c                 8    t                               | |          S r?   )r   r   r  s     r/   r   z#ProductFinitePSpace.compute_density  s    ++D$777r1   N)r5   r6   r7   r8   r9   r   r   r   r   r  r   r:   r1   r/   r3  r3    s          M M XM 	 	 W X	 # # W X#9 9 98 8 8 8 8r1   r3  N)@r8   	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)   r3   r+   r<   r]   rv   r~   r   r   r  r3  r:   r1   r/   <module>rR     s          ) ) ) ) ) ) " " " " " " $ $ $ $ $ $ & & & & & &       ' ' ' ' ' ' ' ' $ $ $ $ $ $ " " " " " " - - - - - - - - & & & & & & 6 6 6 6 6 6 : : : : : : ) ) ) ) ) ) ) ) ( ( ( ( ( ( & & & & & & " " " " " " , , , , , , ' ' ' ' ' ' % % % % % %U U U U U U U U U U U U U U U U U U U U U U U U U U U U
    D   2Q Q Q Q Q< Q Q Q<"6 "6 "6 "6 "6 "6 "6 "6J         -       .- .- .- .- .-/1D .- .- .-b!! !! !! !! !!|^ !! !! !!RyK yK yK yK yK6 yK yK yKxy- y- y- y- y-| y- y- y-x8 8 8 8 82L 8 8 8 8 8r1   