
    wgA                        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?y))*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y)FiniteDensityz'
    A domain with Finite Density.
    c                 ,    t        |      }|| v r| |   S y)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     T/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/stats/frv.py__call__zFiniteDensity.__call__(   s!     t}4<:    c                     t        |       S )z,
        Return item as dictionary.
        )dictr,   s    r.   r2   zFiniteDensity.dict6   s    
 Dzr0   N)__name__
__module____qualname____doc__r/   propertyr2    r0   r.   r*   r*   $   s       r0   r*   c                   V    e Zd ZdZdZed        Zed        Zed        Zd Z	d Z
d Zy	)
FiniteDomainzS
    A domain with discrete finite support

    Represented using a FiniteSet.
    Tc                 :    t        d | j                  D              S )Nc              3   &   K   | ]	  \  }}|  y wNr9   ).0symvals      r.   	<genexpr>z'FiniteDomain.symbols.<locals>.<genexpr>G   s     ;c;s   )r   elementsr3   s    r.   symbolszFiniteDomain.symbolsE   s    ;T]];;;r0   c                      | j                   d   S Nr   argsr3   s    r.   rC   zFiniteDomain.elementsI       yy|r0   c           
      p    t        | j                  D cg c]  }t        t        |             c} S c c}w r>   )r   rC   r   r2   )r,   els     r.   r2   zFiniteDomain.dictM   s'    DMMBb4R>BCCBs   3c                     || j                   v S r>   )rC   r,   others     r.   __contains__zFiniteDomain.__contains__Q   s    %%r0   c                 6    | j                   j                         S r>   )rC   __iter__r3   s    r.   rQ   zFiniteDomain.__iter__T   s    }}%%''r0   c                     t        | D cg c]'  }t        |D cg c]  \  }}t        ||       c}} ) c}}} S c c}}w c c}}}w r>   )r   r   r   )r,   r-   r@   rA   s       r.   
as_booleanzFiniteDomain.as_booleanW   s;    $OO$Ct<83"S#,<=OPP<Os   A>AAN)r4   r5   r6   r7   	is_Finiter8   rD   rC   r2   rO   rQ   rS   r9   r0   r.   r;   r;   =   sZ    
 I< <   D D&(Qr0   r;   c                   b    e Zd ZdZd Zed        Zed        Zed        Zed        Z	d Z
d Zy	)
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.   rY   zSingleFiniteDomain.__new__b   s2    #y)3-S/C}}S&#..r0   c                      | j                   d   S rF   rG   r3   s    r.   r[   zSingleFiniteDomain.symbolh   rI   r0   c                 ,    t        | j                        S r>   )r   r[   r3   s    r.   rD   zSingleFiniteDomain.symbolsl   s    %%r0   c                      | j                   d   S N   rG   r3   s    r.   r\   zSingleFiniteDomain.setp   rI   r0   c           	      x    t        | j                  D cg c]  }t        | j                  |ff       c} S c c}w r>   )r   r\   	frozensetr[   r,   elems     r.   rC   zSingleFiniteDomain.elementst   s0    $((S$9t{{D&9%<=STTSs   7c                 .      fd j                   D        S )Nc              3   N   K   | ]  }t        j                  |ff        y wr>   )rc   r[   r?   re   r,   s     r.   rB   z.SingleFiniteDomain.__iter__.<locals>.<genexpr>y   s"     Gd	DKK.01G   "%r\   r3   s   `r.   rQ   zSingleFiniteDomain.__iter__x   s    GdhhGGr0   c                 b    t        |      d   \  }}|| j                  k(  xr || j                  v S rF   )tupler[   r\   )r,   rN   r@   rA   s       r.   rO   zSingleFiniteDomain.__contains__{   s/    <?Sdkk!5cTXXo5r0   N)r4   r5   r6   r7   rY   r8   r[   rD   r\   rC   rQ   rO   r9   r0   r.   rV   rV   [   si    /   & &   U UH6r0   rV   c                   &    e Zd ZdZd Zed        Zy)ProductFiniteDomainz
    A Finite domain consisting of several other FiniteDomains

    Example: The possibilities of the rolls of three independent dice
    c                 8    t        | j                   }d |D        S )Nc              3   2   K   | ]  }t        |        y wr>   )r$   )r?   itemss     r.   rB   z/ProductFiniteDomain.__iter__.<locals>.<genexpr>   s     555s   )r   domains)r,   proditers     r.   rQ   zProductFiniteDomain.__iter__   s    DLL)5H55r0   c                     t        |  S r>   r   r3   s    r.   rC   zProductFiniteDomain.elements   s    $r0   N)r4   r5   r6   r7   rQ   r8   rC   r9   r0   r.   rn   rn      s     6    r0   rn   c                   >    e Zd ZdZd Zd Zd Zd Zed        Z	d Z
y)	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                 R    |du r|S t        |      }t        j                  | ||      S )zH
        Create a new instance of ConditionalFiniteDomain class
        T)r%   r   rY   )rZ   domain	conditionconds       r.   rY   zConditionalFiniteDomain.__new__   s.     My!}}S&$//r0   c                     | j                   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)ry   xreplacer2   is_Equalitylhsrhs
ValueErrorstr)r,   re   rA   s      r.   _testzConditionalFiniteDomain._test   sX     nn%%d4j1-J__77cgg%%,s3x788r0   c                 D    || j                   v xr | j                  |      S r>   )
fulldomainr   rM   s     r.   rO   z$ConditionalFiniteDomain.__contains__   s    '=DJJu,==r0   c                 .      fd j                   D        S )Nc              3   F   K   | ]  }j                  |      s|  y wr>   )r   rh   s     r.   rB   z3ConditionalFiniteDomain.__iter__.<locals>.<genexpr>   s     EDJJt4DEs   !!)r   r3   s   `r.   rQ   z ConditionalFiniteDomain.__iter__   s    EEEr0   c           	          t        | j                  t              rNt        | j                  j                  D cg c](  }t        | j                  j                  |ff      | v r|* c} S t        d      c c}w )Nz7Not implemented on multi-dimensional conditional domain)rX   r   rV   r   r\   rc   r[   NotImplementedErrorrd   s     r.   r\   zConditionalFiniteDomain.set   sz    doo'9:0C0C X"+doo.D.Dd-K,M"NRV"V  $ X Y Y &IK KXs   -A4c                 ,    t         j                  |       S r>   )r;   rS   r3   s    r.   rS   z"ConditionalFiniteDomain.as_boolean   s    &&t,,r0   N)r4   r5   r6   r7   rY   r   rO   rQ   r8   r\   rS   r9   r0   r.   rv   rv      s7    09>F K K-r0   rv   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y)SingleFiniteDistributionc                 `    t        t        t        |            }t        j                  | g| S r>   )listmapr   r   rY   )rZ   rH   s     r.   rY   z SingleFiniteDistribution.__new__   s'    C&'}}S(4((r0   c                       y r>   r9   rG   s    r.   checkzSingleFiniteDistribution.check   s    r0   c                     | j                   rt        |       S | j                  D ci c]  }|| j                  |       c}S c c}w r>   )is_symbolicr'   r\   pmf)r,   ks     r.   r2   zSingleFiniteDistribution.dict   s;     4= (,11488A;111s   Ac                     t               r>   r   r,   rH   s     r.   r   zSingleFiniteDistribution.pmf   s    !##r0   c                     t               r>   r   r3   s    r.   r\   zSingleFiniteDistribution.set   s    !##r0   c                 .    | j                   j                  S r>   )r2   valuesr3   s    r.   <lambda>z!SingleFiniteDistribution.<lambda>   s    499#3#3 r0   c                 .    | j                   j                  S r>   )r2   rq   r3   s    r.   r   z!SingleFiniteDistribution.<lambda>   s    $))// r0   c                      y)NFr9   r3   s    r.   r   z!SingleFiniteDistribution.<lambda>   s    r0   c                 .    | j                   j                  S r>   )r2   rQ   r3   s    r.   r   z!SingleFiniteDistribution.<lambda>   s    TYY%7%7 r0   c                 .    | j                   j                  S r>   )r2   __getitem__r3   s    r.   r   z!SingleFiniteDistribution.<lambda>   s    		(=(= r0   c                       | j                   | S r>   )r   r   s     r.   r/   z!SingleFiniteDistribution.__call__   s    txxr0   c                     || j                   v S r>   rj   rM   s     r.   rO   z%SingleFiniteDistribution.__contains__   s      r0   N)r4   r5   r6   rY   staticmethodr   r8   r   r2   r   r\   r   rq   r   rQ   r   r/   rO   r9   r0   r.   r   r      s    )   2  2
$ $ $ 34F12E-.K78H=>K!r0   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y)FinitePSpacezd
    A Finite Probability Space

    Represents the probabilities of a finite number of events.
    Tc                     |j                         D ci c]  \  }}t        |      t        |       }}}t        |      }t        j                  | ||      }||_        |S c c}}w r>   )rq   r   r   r    rY   _density)rZ   rx   densitykeyrA   public_densityobjs          r.   rY   zFinitePSpace.__new__   sb     '1C 3<- 1 1gnnS&.9
1s   A!c                 "   t        |      }| j                  }t        t        |j	                               d   t
              r |j                  |t        j                        S |j                  t        |      d   d   t        j                        S )Nr   ra   )
r   r   rX   r   keysr   getr   Zerorl   )r,   re   r   s      r.   prob_ofzFinitePSpace.prob_of   se    t}--d7<<>*1-y9;;tQVV,,{{5;q>!,aff55r0   c                 n     t         fdt        |      D              sJ t         j                  |      S )Nc              3   N   K   | ]  }|j                   j                  v   y wr>   )r[   rD   )r?   rr,   s     r.   rB   z%FinitePSpace.where.<locals>.<genexpr>  s     O188t||+Ori   )allr#   rv   rx   r,   ry   s   ` r.   wherezFinitePSpace.where  s-    O^I5NOOOO&t{{I>>r0   c                 
   t        || j                        }t               }| j                  D ]S  }|j	                  t        |            }| j                  |      }|j                  |t        j                        |z   ||<   U |S r>   )
r%   r   r*   rx   r|   r2   r   r   r   r   )r,   exprdre   rA   probs         r.   compute_densityzFinitePSpace.compute_density  sp    tT[[)OKK 	/D--T
+C<<%DUU3'$.AcF	/ r0   c                     | j                  |      }t        j                  }g }t        |      D ]  }||   }||z  }|j	                  ||f       ! t        |      S r>   )r   r   r   sortedappendr2   )r,   r   r   cum_probcdfr   r   s          r.   compute_cdfzFinitePSpace.compute_cdf  sb      &66!9 	(CS6DHJJX'	(
 Cyr0   c                     | j                  |      }t        |j                               }t        |d       }|r|D cg c]  \  }}|t	        |      f }}}|S c c}}w )Nc                     | d   S r`   r9   )val_cumprobs    r.   r   z)FinitePSpace.sorted_cdf.<locals>.<lambda>  s
    [^ r0   )r   )r   r   rq   r   float)r,   r   python_floatr   rq   sorted_itemsvr   s           r.   
sorted_cdfzFinitePSpace.sorted_cdf  sg    t$SYY[!e)KL'35#8 h0 5L 55s    Ac                     | j                  |      }t        dd      t        t        fd|j	                         D                    S )NtTrealc              3   T   K   | ]  \  }}t        t        |z  z        |z   ! y wr>   )r   r	   r?   r   r   r   s      r.   rB   z?FinitePSpace.compute_characteristic_function.<locals>.<genexpr>*  s%     ?caS1QZ\?s   %(r   r   r   sumrq   r,   r   r   r   s      @r.   compute_characteristic_functionz,FinitePSpace.compute_characteristic_function%  s=      &#D!a?QWWY??@@r0   c                     | j                  |      }t        dd      t        t        fd|j	                         D                    S )Nr   Tr   c              3   F   K   | ]  \  }}t        |z        |z    y wr>   r   r   s      r.   rB   zBFinitePSpace.compute_moment_generating_function.<locals>.<genexpr>1  s!     =CAaS1XaZ=s   !r   r   s      @r.   "compute_moment_generating_functionz/FinitePSpace.compute_moment_generating_function,  s=      &#D!a=1779==>>r0   Nc                 j   |xs | j                   }t        ||      }| j                  D cg c]  }| j                  |       }}t	        |t
        t        f      rZ| j                  D cg c]  }t        |      d   d    }}| j                  D cg c]  }|j                  t        |             }}nJ| j                  D cg c]  }|j                  t        |             }}| j                  D cg c]  }d }}t        d t        |||      D              S c c}w c c}w c c}w c c}w c c}w )Nr   ra   Tc              3   f   K   | ])  \  }}}t        ||z  |ft        j                  d f       + yw)TN)r   r   r   )r?   r   re   blvs       r.   rB   z3FinitePSpace.compute_expectation.<locals>.<genexpr>=  s8      H#D$ dTk3/!&&$@ Hs   /1)r   r%   rx   r   rX   r   r   rl   r|   r2   r   zip)r,   r   rvskwargsre   probsparse_domainboolss           r.   compute_expectationz FinitePSpace.compute_expectation3  s    T[[tS!04<d#<<dUJ/0:>++F$E$KN1-FLF;?;;G4T]]4:.GEGBF++N$DMM$t*5NLN&*kk2dT2E2 H'*5,'FH H 	H =FGN2s   D)D!!D&!D+4	D0c                     | j                  |      }t        dd      }t        |dk  |dkD  z  ff}|j                         D ]  \  }}||||k  ffz   } t	        |t        |       S )NpTr   r   ra   )r   r   r
   rq   r   r   )r,   r   r   r   r\   r   values          r.   compute_quantilezFinitePSpace.compute_quantile@  sx    t$#D!a!eA&')))+ 	.JC#qEz*--C	.aC))r0   c                 L    t        d t              D              }t              }|j                   j                        s$t        dt        | j                  z
        z        t        t              r|j                  j                   j                  j                        sRt        j                  t              rj                  nj                  t         fd j                  D              S t        t         fd j!                        D                    S )Nc              3   4   K   | ]  }|j                     y wr>   )r[   )r?   rss     r.   rB   z+FinitePSpace.probability.<locals>.<genexpr>I  s      Or Os   z)Cannot compare foreign random symbols, %sc           
   3      K   | ]P  }t        j                  |      j                  t        |      d    d         ft        j
                  df       R yw)r   ra   TN)r   r   subsr   r   r   )r?   re   ry   rvr,   s     r.   rB   z+FinitePSpace.probability.<locals>.<genexpr>Q  sT      @+/ !T*INN2tDz!}Q?O,PQ~' @s   AAc              3   @   K   | ]  }j                  |        y wr>   )r   rh   s     r.   rB   z+FinitePSpace.probability.<locals>.<genexpr>T  s     P$4<<-Ps   )rc   r#   r%   issubsetrD   r   r   rX   r   free_symbolsrx   r   r   r~   r   r   r   )r,   ry   cond_symbolsrz   r   s   ``  @r.   probabilityzFinitePSpace.probabilityH  s      O^I5N OOy!$$T\\2H"<$,,#>?A B Bi,""++DKK,D,DE",Y]]F"CB @37;;@ @ @ sP$**Y:OPPQQr0   c                     | j                  |      }| j                  |      }| j                  j                         D ci c]  \  }}|j	                  |      r|||z   }}}t        ||      S c c}}w r>   )r   r   r   rq   r   r   r,   ry   rx   r   r   rA   r   s          r.   conditional_spacezFinitePSpace.conditional_spaceV  sw    I&	* $ 3 3 5LCc9J d
? L LFG,,Ls    !A0c                 T    | j                   | 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JJr0   )Fr>   )r9   scipyN)r4   r5   r6   r7   rT   rY   r   r   r   r   r   r   r   r   r   r   r   r   r   r9   r0   r.   r   r      s    
 I6? 	 	   A A ? ?H*R-Kr0   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y)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                 V    t        | j                  | j                  j                        S r>   )rV   r[   r   r\   r3   s    r.   rx   zSingleFinitePSpace.domainp  s    !$++t/@/@/D/DEEr0   c                 .    | j                   j                  S )z
        Helper property to check if the distribution
        of the random variable is having symbolic
        dimension.
        )r   r   r3   s    r.   _is_symboliczSingleFinitePSpace._is_symbolict  s       ,,,r0   c                      | j                   d   S r`   rG   r3   s    r.   r   zSingleFinitePSpace.distribution}  rI   r0   c                 8    | j                   j                  |      S r>   )r   r   r,   r   s     r.   r   zSingleFinitePSpace.pmf  s      $$T**r0   c                     | j                   j                  j                         D ci c]  \  }}t        | j                  |f      | c}}S c c}}w r>   )r   r2   rq   r   r[   )r,   rA   r   s      r.   r   zSingleFinitePSpace._density  sT     &*%6%6%;%;%A%A%CE!T 4;;,-t3 E 	E Es   "Ac           
         | j                   r| j                  |      }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                        j                  |      S Nr   Tr   kira   )r   r   r   r   r   r   r	   rH   lowhighr%   r   r   rx   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9I9I499UV<K\K\4]^__tT[[)DKK):):;[[\`aar0   c           
         | j                   r| j                  |      }t        dd      }t        d      }t        |t	         ||      t        ||z        z  || j                  d   j                  | j                  d   j                  f            S t        || j                        }t        | j                  | j                        j                  |      S r  )r   r   r   r   r   r   rH   r  r  r%   r   r   rx   r   r   r  s        r.   r   z5SingleFinitePSpace.compute_moment_generating_function  s    $$T*Ac%AtB!S2s2a4y2tyy|7G7GSTIZIZ2[\]]tT[[)DKK):):;^^_cddr0   c                     | j                   rt        d      t        || j                        }t	        | j
                  | 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   rx   r   r   r  s     r.   r   z#SingleFinitePSpace.compute_quantile  sQ    % '% & & tT[[)DKK):):;LLTRRr0   c                 ,   | j                   rt        t        |            d   }t        dd      }t	        |t
        t        f      sdn|j                  ||      }t        |t        | j                  |      t        || j                  d   j                  k\  || j                  d   j                  k  |      ft        j                   df            S t#        || j$                        }t'        | j(                  | j*                        j-                  |      S )Nr   r   Tintegerra   )r   r   r#   r   rX   r   r   r   r   r   r   r   rH   r  r  r   r   r%   r   r   rx   r   r   )r,   r   r   r   rz   s        r.   r   z"SingleFinitePSpace.compute_density  s    nT*+A.Bc4(A)$U0CD4))B* !txx{CTYYq\-=-=(=1"""D%* +-.VVTN<= = tT[[)DKK):):;KKDQQr0   c           	      ^   | j                   r]| j                  |      }t        d      }t        d      }t        |t	         ||      || j
                  d   j                  |f            S t        || j                        }t        | j                  | j                        j                  |      S )Nr   r  ra   )r   r   r   r   r   rH   r  r%   r   r   rx   r   r   )r,   r   r   r   r  s        r.   r   zSingleFinitePSpace.compute_cdf  s    $$T*Ac
AtB!S2TYYq\-=-=q(ABCCtT[[)DKK):):;GGMMr0   Nc                 V   | j                   rt        |      d   }t        dd      }|j                  ||      }t	        |t
        t        f      sdn|}|dk7  r| j                  |      |z  n| j                  |      |z  }t        t        ||ft        j                  df      || j                  j                  | j                  j                  f      j                         S t!        |      }t#        ||      } t%        | j&                  | j                        j(                  ||fi |S )Nr   r   Tr  )r   r#   r   r   rX   r   r   r   r   r   r   r   r   r  r  doitr   r%   r   rx   r   )r,   r   r   r   r   r   rz   funcs           r.   r   z&SingleFinitePSpace.compute_expectation  s   %a(Bc4(A99R#D)$U0CD4 &*dl488A;?d8JDy$~>D%%))4+<+<+A+ABDDHDFK ~tS!O|DKK):):;OOPTVYd]cddr0   c                     | j                   rt        d      t        |      }t        | j                  | j
                        j                  |      S )NzhCurrently, probability queries are not supported for random variables with symbolic sized distributions.)r   r   r%   r   rx   r   r   r   s     r.   r   zSingleFinitePSpace.probability  sL    % 'P Q QI&	DKK):):;GG	RRr0   c                    | j                   r|  | j                  |      }| j                  |      }| j                  j	                         D ci c]  \  }}|j                  |      r|||z   }}}t        ||      S c c}}w )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   rq   r   r   r   s          r.   r   z$SingleFinitePSpace.conditional_space  s     I&	* $ 3 3 5LCc9J d
? L LFG,,Ls   !A>r>   )r4   r5   r6   r7   r8   rx   r   r   r   r   r   r   r   r   r   r   r   r   r   r9   r0   r.   r   r   f  s     F F - -  + E  E b b e eS
RNeS-r0   r   c                   `    e Zd ZdZed        Zeed               Zeed               Zd Z	d Z
y)ProductFinitePSpacezG
    A collection of several independent finite probability spaces
    c                 `    t        | j                  D cg c]  }|j                   c} S c c}w r>   )rn   spacesrx   )r,   spaces     r.   rx   zProductFinitePSpace.domain  s#    "t{{$KeU\\$KLL$Ks   +c           	      P   t        | j                  D cg c]%  }t        |j                  j	                               ' c} }i }|D ]O  }t        t        |       \  }}t        |      }t        | }|j                  |t        j                        |z   ||<   Q t        |      S c c}w r>   )r   r  iterr   rq   r   r   r$   r   r   r   r   r   )	r,   r  rs   r   rq   elemsr   re   r   s	            r.   r   zProductFinitePSpace._density  s     & "%.."6"6"89 & ' 	1EU,LE55>D;DeeD!&&)D0AdG		1
 Aw&s   *B#c                 ,    t        | j                        S r>   )r   r   r3   s    r.   r   zProductFinitePSpace.density  s     DMM""r0   c                 .    t         j                  | |      S r>   )r   r   r   s     r.   r   zProductFinitePSpace.probability  s    ''i88r0   c                 .    t         j                  | |      S r>   )r   r   r  s     r.   r   z#ProductFinitePSpace.compute_density  s    ++D$77r0   N)r4   r5   r6   r7   r8   rx   r   r   r   r   r   r9   r0   r.   r  r    s_     M M 	  	 #  #98r0   r  N)@r7   	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(   r2   r*   r;   rV   rn   rv   r   r   r   r  r9   r0   r.   <module>r1     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 8r0   