Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/18.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:175f191b8c7cc6115692bde56dc7c9e22924ad639e20c839427c8a2617c99c20
+size 33555612

ckpts/universal/global_step80/zero/18.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87b94c4442ab0d21bb06f719b66772cb00996b1bda6c695c1a344f1290da1353
+size 33555627

ckpts/universal/global_step80/zero/18.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:492bc29e64bea810c751a186153489871fe93e3d646018cd153e29c3e561445d
+size 33555533

ckpts/universal/global_step80/zero/20.input_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1b074fced662f4d5015cdf1941a7555f15b2a01225f952d5eb86cdf75b24093
+size 9372

ckpts/universal/global_step80/zero/20.input_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f86b29c6332f1056cb30ba0c34d84ff35f141794d4fff5f0f5d1267fc9de7873
+size 9387

ckpts/universal/global_step80/zero/22.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:227728043f5b430c5e468dc26f97f7cb1c65cb4e2a9a0281c75412ce8c3f6125
+size 33555612

ckpts/universal/global_step80/zero/22.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d03a0ff087b9919bb9c72635a43f9bcf431a3681633b6a676568c761933c9c6
+size 33555627

ckpts/universal/global_step80/zero/3.post_attention_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da1196c99bfa9cbcf4c6c4978a40245d9dc2a6d0226e90cb01bae1d2581979aa
+size 9293

venv/lib/python3.10/site-packages/sympy/stats/__init__.py

@@ -0,0 +1,202 @@
+"""
+SymPy statistics module
+
+Introduces a random variable type into the SymPy language.
+
+Random variables may be declared using prebuilt functions such as
+Normal, Exponential, Coin, Die, etc...  or built with functions like FiniteRV.
+
+Queries on random expressions can be made using the functions
+
+========================= =============================
+    Expression                    Meaning
+------------------------- -----------------------------
+ ``P(condition)``          Probability
+ ``E(expression)``         Expected value
+ ``H(expression)``         Entropy
+ ``variance(expression)``  Variance
+ ``density(expression)``   Probability Density Function
+ ``sample(expression)``    Produce a realization
+ ``where(condition)``      Where the condition is true
+========================= =============================
+
+Examples
+========
+
+>>> from sympy.stats import P, E, variance, Die, Normal
+>>> from sympy import simplify
+>>> X, Y = Die('X', 6), Die('Y', 6) # Define two six sided dice
+>>> Z = Normal('Z', 0, 1) # Declare a Normal random variable with mean 0, std 1
+>>> P(X>3) # Probability X is greater than 3
+1/2
+>>> E(X+Y) # Expectation of the sum of two dice
+7
+>>> variance(X+Y) # Variance of the sum of two dice
+35/6
+>>> simplify(P(Z>1)) # Probability of Z being greater than 1
+1/2 - erf(sqrt(2)/2)/2
+
+
+One could also create custom distribution and define custom random variables
+as follows:
+
+1. If you want to create a Continuous Random Variable:
+
+>>> from sympy.stats import ContinuousRV, P, E
+>>> from sympy import exp, Symbol, Interval, oo
+>>> x = Symbol('x')
+>>> pdf = exp(-x) # pdf of the Continuous Distribution
+>>> Z = ContinuousRV(x, pdf, set=Interval(0, oo))
+>>> E(Z)
+1
+>>> P(Z > 5)
+exp(-5)
+
+1.1 To create an instance of Continuous Distribution:
+
+>>> from sympy.stats import ContinuousDistributionHandmade
+>>> from sympy import Lambda
+>>> dist = ContinuousDistributionHandmade(Lambda(x, pdf), set=Interval(0, oo))
+>>> dist.pdf(x)
+exp(-x)
+
+2. If you want to create a Discrete Random Variable:
+
+>>> from sympy.stats import DiscreteRV, P, E
+>>> from sympy import Symbol, S
+>>> p = S(1)/2
+>>> x = Symbol('x', integer=True, positive=True)
+>>> pdf = p*(1 - p)**(x - 1)
+>>> D = DiscreteRV(x, pdf, set=S.Naturals)
+>>> E(D)
+2
+>>> P(D > 3)
+1/8
+
+2.1 To create an instance of Discrete Distribution:
+
+>>> from sympy.stats import DiscreteDistributionHandmade
+>>> from sympy import Lambda
+>>> dist = DiscreteDistributionHandmade(Lambda(x, pdf), set=S.Naturals)
+>>> dist.pdf(x)
+2**(1 - x)/2
+
+3. If you want to create a Finite Random Variable:
+
+>>> from sympy.stats import FiniteRV, P, E
+>>> from sympy import Rational, Eq
+>>> pmf = {1: Rational(1, 3), 2: Rational(1, 6), 3: Rational(1, 4), 4: Rational(1, 4)}
+>>> X = FiniteRV('X', pmf)
+>>> E(X)
+29/12
+>>> P(X > 3)
+1/4
+
+3.1 To create an instance of Finite Distribution:
+
+>>> from sympy.stats import FiniteDistributionHandmade
+>>> dist = FiniteDistributionHandmade(pmf)
+>>> dist.pmf(x)
+Lambda(x, Piecewise((1/3, Eq(x, 1)), (1/6, Eq(x, 2)), (1/4, Eq(x, 3) | Eq(x, 4)), (0, True)))
+"""
+
+__all__ = [
+    'P', 'E', 'H', 'density', 'where', 'given', 'sample', 'cdf','median',
+    'characteristic_function', 'pspace', 'sample_iter', 'variance', 'std',
+    'skewness', 'kurtosis', 'covariance', 'dependent', 'entropy', 'independent',
+    'random_symbols', 'correlation', 'factorial_moment', 'moment', 'cmoment',
+    'sampling_density', 'moment_generating_function', 'smoment', 'quantile',
+    'coskewness', 'sample_stochastic_process',
+
+    'FiniteRV', 'DiscreteUniform', 'Die', 'Bernoulli', 'Coin', 'Binomial',
+    'BetaBinomial', 'Hypergeometric', 'Rademacher', 'IdealSoliton', 'RobustSoliton',
+    'FiniteDistributionHandmade',
+
+    'ContinuousRV', 'Arcsin', 'Benini', 'Beta', 'BetaNoncentral', 'BetaPrime',
+    'BoundedPareto', 'Cauchy', 'Chi', 'ChiNoncentral', 'ChiSquared', 'Dagum', 'Erlang',
+    'ExGaussian', 'Exponential', 'ExponentialPower', 'FDistribution',
+    'FisherZ', 'Frechet', 'Gamma', 'GammaInverse', 'Gompertz', 'Gumbel',
+    'Kumaraswamy', 'Laplace', 'Levy', 'Logistic','LogCauchy', 'LogLogistic', 'LogitNormal', 'LogNormal', 'Lomax',
+    'Moyal', 'Maxwell', 'Nakagami', 'Normal', 'GaussianInverse', 'Pareto', 'PowerFunction',
+    'QuadraticU', 'RaisedCosine', 'Rayleigh','Reciprocal', 'StudentT', 'ShiftedGompertz',
+    'Trapezoidal', 'Triangular', 'Uniform', 'UniformSum', 'VonMises', 'Wald',
+    'Weibull', 'WignerSemicircle', 'ContinuousDistributionHandmade',
+
+    'FlorySchulz', 'Geometric','Hermite', 'Logarithmic', 'NegativeBinomial', 'Poisson', 'Skellam',
+    'YuleSimon', 'Zeta', 'DiscreteRV', 'DiscreteDistributionHandmade',
+
+    'JointRV', 'Dirichlet', 'GeneralizedMultivariateLogGamma',
+    'GeneralizedMultivariateLogGammaOmega', 'Multinomial', 'MultivariateBeta',
+    'MultivariateEwens', 'MultivariateT', 'NegativeMultinomial',
+    'NormalGamma', 'MultivariateNormal', 'MultivariateLaplace', 'marginal_distribution',
+
+    'StochasticProcess', 'DiscreteTimeStochasticProcess',
+    'DiscreteMarkovChain', 'TransitionMatrixOf', 'StochasticStateSpaceOf',
+    'GeneratorMatrixOf', 'ContinuousMarkovChain', 'BernoulliProcess',
+    'PoissonProcess', 'WienerProcess', 'GammaProcess',
+
+    'CircularEnsemble', 'CircularUnitaryEnsemble',
+    'CircularOrthogonalEnsemble', 'CircularSymplecticEnsemble',
+    'GaussianEnsemble', 'GaussianUnitaryEnsemble',
+    'GaussianOrthogonalEnsemble', 'GaussianSymplecticEnsemble',
+    'joint_eigen_distribution', 'JointEigenDistribution',
+    'level_spacing_distribution',
+
+    'MatrixGamma', 'Wishart', 'MatrixNormal', 'MatrixStudentT',
+
+    'Probability', 'Expectation', 'Variance', 'Covariance', 'Moment',
+    'CentralMoment',
+
+    'ExpectationMatrix', 'VarianceMatrix', 'CrossCovarianceMatrix'
+
+]
+from .rv_interface import (P, E, H, density, where, given, sample, cdf, median,
+        characteristic_function, pspace, sample_iter, variance, std, skewness,
+        kurtosis, covariance, dependent, entropy, independent, random_symbols,
+        correlation, factorial_moment, moment, cmoment, sampling_density,
+        moment_generating_function, smoment, quantile, coskewness,
+        sample_stochastic_process)
+
+from .frv_types import (FiniteRV, DiscreteUniform, Die, Bernoulli, Coin,
+        Binomial, BetaBinomial, Hypergeometric, Rademacher,
+        FiniteDistributionHandmade, IdealSoliton, RobustSoliton)
+
+from .crv_types import (ContinuousRV, Arcsin, Benini, Beta, BetaNoncentral,
+        BetaPrime, BoundedPareto, Cauchy, Chi, ChiNoncentral, ChiSquared,
+        Dagum, Erlang, ExGaussian, Exponential, ExponentialPower,
+        FDistribution, FisherZ, Frechet, Gamma, GammaInverse, GaussianInverse,
+        Gompertz, Gumbel, Kumaraswamy, Laplace, Levy, Logistic, LogCauchy,
+        LogLogistic, LogitNormal, LogNormal, Lomax, Maxwell, Moyal, Nakagami,
+        Normal, Pareto, QuadraticU, RaisedCosine, Rayleigh, Reciprocal,
+        StudentT, PowerFunction, ShiftedGompertz, Trapezoidal, Triangular,
+        Uniform, UniformSum, VonMises, Wald, Weibull, WignerSemicircle,
+        ContinuousDistributionHandmade)
+
+from .drv_types import (FlorySchulz, Geometric, Hermite, Logarithmic, NegativeBinomial, Poisson,
+        Skellam, YuleSimon, Zeta, DiscreteRV, DiscreteDistributionHandmade)
+
+from .joint_rv_types import (JointRV, Dirichlet,
+        GeneralizedMultivariateLogGamma, GeneralizedMultivariateLogGammaOmega,
+        Multinomial, MultivariateBeta, MultivariateEwens, MultivariateT,
+        NegativeMultinomial, NormalGamma, MultivariateNormal, MultivariateLaplace,
+        marginal_distribution)
+
+from .stochastic_process_types import (StochasticProcess,
+        DiscreteTimeStochasticProcess, DiscreteMarkovChain,
+        TransitionMatrixOf, StochasticStateSpaceOf, GeneratorMatrixOf,
+        ContinuousMarkovChain, BernoulliProcess, PoissonProcess, WienerProcess,
+        GammaProcess)
+
+from .random_matrix_models import (CircularEnsemble, CircularUnitaryEnsemble,
+        CircularOrthogonalEnsemble, CircularSymplecticEnsemble,
+        GaussianEnsemble, GaussianUnitaryEnsemble, GaussianOrthogonalEnsemble,
+        GaussianSymplecticEnsemble, joint_eigen_distribution,
+        JointEigenDistribution, level_spacing_distribution)
+
+from .matrix_distributions import MatrixGamma, Wishart, MatrixNormal, MatrixStudentT
+
+from .symbolic_probability import (Probability, Expectation, Variance,
+        Covariance, Moment, CentralMoment)
+
+from .symbolic_multivariate_probability import (ExpectationMatrix, VarianceMatrix,
+        CrossCovarianceMatrix)

venv/lib/python3.10/site-packages/sympy/stats/compound_rv.py

@@ -0,0 +1,223 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.symbol import Dummy
+from sympy.integrals.integrals import Integral
+from sympy.stats.rv import (NamedArgsMixin, random_symbols, _symbol_converter,
+                        PSpace, RandomSymbol, is_random, Distribution)
+from sympy.stats.crv import ContinuousDistribution, SingleContinuousPSpace
+from sympy.stats.drv import DiscreteDistribution, SingleDiscretePSpace
+from sympy.stats.frv import SingleFiniteDistribution, SingleFinitePSpace
+from sympy.stats.crv_types import ContinuousDistributionHandmade
+from sympy.stats.drv_types import DiscreteDistributionHandmade
+from sympy.stats.frv_types import FiniteDistributionHandmade
+
+
+class CompoundPSpace(PSpace):
+    """
+    A temporary Probability Space for the Compound Distribution. After
+    Marginalization, this returns the corresponding Probability Space of the
+    parent distribution.
+    """
+
+    def __new__(cls, s, distribution):
+        s = _symbol_converter(s)
+        if isinstance(distribution, ContinuousDistribution):
+            return SingleContinuousPSpace(s, distribution)
+        if isinstance(distribution, DiscreteDistribution):
+            return SingleDiscretePSpace(s, distribution)
+        if isinstance(distribution, SingleFiniteDistribution):
+            return SingleFinitePSpace(s, distribution)
+        if not isinstance(distribution, CompoundDistribution):
+            raise ValueError("%s should be an isinstance of "
+                        "CompoundDistribution"%(distribution))
+        return Basic.__new__(cls, s, distribution)
+
+    @property
+    def value(self):
+        return RandomSymbol(self.symbol, self)
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def is_Continuous(self):
+        return self.distribution.is_Continuous
+
+    @property
+    def is_Finite(self):
+        return self.distribution.is_Finite
+
+    @property
+    def is_Discrete(self):
+        return self.distribution.is_Discrete
+
+    @property
+    def distribution(self):
+        return self.args[1]
+
+    @property
+    def pdf(self):
+        return self.distribution.pdf(self.symbol)
+
+    @property
+    def set(self):
+        return self.distribution.set
+
+    @property
+    def domain(self):
+        return self._get_newpspace().domain
+
+    def _get_newpspace(self, evaluate=False):
+        x = Dummy('x')
+        parent_dist = self.distribution.args[0]
+        func = Lambda(x, self.distribution.pdf(x, evaluate))
+        new_pspace = self._transform_pspace(self.symbol, parent_dist, func)
+        if new_pspace is not None:
+            return new_pspace
+        message = ("Compound Distribution for %s is not implemented yet" % str(parent_dist))
+        raise NotImplementedError(message)
+
+    def _transform_pspace(self, sym, dist, pdf):
+        """
+        This function returns the new pspace of the distribution using handmade
+        Distributions and their corresponding pspace.
+        """
+        pdf = Lambda(sym, pdf(sym))
+        _set = dist.set
+        if isinstance(dist, ContinuousDistribution):
+            return SingleContinuousPSpace(sym, ContinuousDistributionHandmade(pdf, _set))
+        elif isinstance(dist, DiscreteDistribution):
+            return SingleDiscretePSpace(sym, DiscreteDistributionHandmade(pdf, _set))
+        elif isinstance(dist, SingleFiniteDistribution):
+            dens = {k: pdf(k) for k in _set}
+            return SingleFinitePSpace(sym, FiniteDistributionHandmade(dens))
+
+    def compute_density(self, expr, *, compound_evaluate=True, **kwargs):
+        new_pspace = self._get_newpspace(compound_evaluate)
+        expr = expr.subs({self.value: new_pspace.value})
+        return new_pspace.compute_density(expr, **kwargs)
+
+    def compute_cdf(self, expr, *, compound_evaluate=True, **kwargs):
+        new_pspace = self._get_newpspace(compound_evaluate)
+        expr = expr.subs({self.value: new_pspace.value})
+        return new_pspace.compute_cdf(expr, **kwargs)
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        new_pspace = self._get_newpspace(evaluate)
+        expr = expr.subs({self.value: new_pspace.value})
+        if rvs:
+            rvs = rvs.subs({self.value: new_pspace.value})
+        if isinstance(new_pspace, SingleFinitePSpace):
+            return new_pspace.compute_expectation(expr, rvs, **kwargs)
+        return new_pspace.compute_expectation(expr, rvs, evaluate, **kwargs)
+
+    def probability(self, condition, *, compound_evaluate=True, **kwargs):
+        new_pspace = self._get_newpspace(compound_evaluate)
+        condition = condition.subs({self.value: new_pspace.value})
+        return new_pspace.probability(condition)
+
+    def conditional_space(self, condition, *, compound_evaluate=True, **kwargs):
+        new_pspace = self._get_newpspace(compound_evaluate)
+        condition = condition.subs({self.value: new_pspace.value})
+        return new_pspace.conditional_space(condition)
+
+
+class CompoundDistribution(Distribution, NamedArgsMixin):
+    """
+    Class for Compound Distributions.
+
+    Parameters
+    ==========
+
+    dist : Distribution
+        Distribution must contain a random parameter
+
+    Examples
+    ========
+
+    >>> from sympy.stats.compound_rv import CompoundDistribution
+    >>> from sympy.stats.crv_types import NormalDistribution
+    >>> from sympy.stats import Normal
+    >>> from sympy.abc import x
+    >>> X = Normal('X', 2, 4)
+    >>> N = NormalDistribution(X, 4)
+    >>> C = CompoundDistribution(N)
+    >>> C.set
+    Interval(-oo, oo)
+    >>> C.pdf(x, evaluate=True).simplify()
+    exp(-x**2/64 + x/16 - 1/16)/(8*sqrt(pi))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Compound_probability_distribution
+
+    """
+
+    def __new__(cls, dist):
+        if not isinstance(dist, (ContinuousDistribution,
+                SingleFiniteDistribution, DiscreteDistribution)):
+            message = "Compound Distribution for %s is not implemented yet" % str(dist)
+            raise NotImplementedError(message)
+        if not cls._compound_check(dist):
+            return dist
+        return Basic.__new__(cls, dist)
+
+    @property
+    def set(self):
+        return self.args[0].set
+
+    @property
+    def is_Continuous(self):
+        return isinstance(self.args[0], ContinuousDistribution)
+
+    @property
+    def is_Finite(self):
+        return isinstance(self.args[0], SingleFiniteDistribution)
+
+    @property
+    def is_Discrete(self):
+        return isinstance(self.args[0], DiscreteDistribution)
+
+    def pdf(self, x, evaluate=False):
+        dist = self.args[0]
+        randoms = [rv for rv in dist.args if is_random(rv)]
+        if isinstance(dist, SingleFiniteDistribution):
+            y = Dummy('y', integer=True, negative=False)
+            expr = dist.pmf(y)
+        else:
+            y = Dummy('y')
+            expr = dist.pdf(y)
+        for rv in randoms:
+            expr = self._marginalise(expr, rv, evaluate)
+        return Lambda(y, expr)(x)
+
+    def _marginalise(self, expr, rv, evaluate):
+        if isinstance(rv.pspace.distribution, SingleFiniteDistribution):
+            rv_dens = rv.pspace.distribution.pmf(rv)
+        else:
+            rv_dens = rv.pspace.distribution.pdf(rv)
+        rv_dom = rv.pspace.domain.set
+        if rv.pspace.is_Discrete or rv.pspace.is_Finite:
+            expr = Sum(expr*rv_dens, (rv, rv_dom._inf,
+                    rv_dom._sup))
+        else:
+            expr = Integral(expr*rv_dens, (rv, rv_dom._inf,
+                    rv_dom._sup))
+        if evaluate:
+            return expr.doit()
+        return expr
+
+    @classmethod
+    def _compound_check(self, dist):
+        """
+        Checks if the given distribution contains random parameters.
+        """
+        randoms = []
+        for arg in dist.args:
+            randoms.extend(random_symbols(arg))
+        if len(randoms) == 0:
+            return False
+        return True

venv/lib/python3.10/site-packages/sympy/stats/crv.py

@@ -0,0 +1,570 @@
+"""
+Continuous Random Variables Module
+
+See Also
+========
+sympy.stats.crv_types
+sympy.stats.rv
+sympy.stats.frv
+"""
+
+
+from sympy.core.basic import Basic
+from sympy.core.cache import cacheit
+from sympy.core.function import Lambda, PoleError
+from sympy.core.numbers import (I, nan, oo)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.core.sympify import _sympify, sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, Or)
+from sympy.polys.polyerrors import PolynomialError
+from sympy.polys.polytools import poly
+from sympy.series.series import series
+from sympy.sets.sets import (FiniteSet, Intersection, Interval, Union)
+from sympy.solvers.solveset import solveset
+from sympy.solvers.inequalities import reduce_rational_inequalities
+from sympy.stats.rv import (RandomDomain, SingleDomain, ConditionalDomain, is_random,
+        ProductDomain, PSpace, SinglePSpace, random_symbols, NamedArgsMixin, Distribution)
+
+
+class ContinuousDomain(RandomDomain):
+    """
+    A domain with continuous support
+
+    Represented using symbols and Intervals.
+    """
+    is_Continuous = True
+
+    def as_boolean(self):
+        raise NotImplementedError("Not Implemented for generic Domains")
+
+
+class SingleContinuousDomain(ContinuousDomain, SingleDomain):
+    """
+    A univariate domain with continuous support
+
+    Represented using a single symbol and interval.
+    """
+    def compute_expectation(self, expr, variables=None, **kwargs):
+        if variables is None:
+            variables = self.symbols
+        if not variables:
+            return expr
+        if frozenset(variables) != frozenset(self.symbols):
+            raise ValueError("Values should be equal")
+        # assumes only intervals
+        return Integral(expr, (self.symbol, self.set), **kwargs)
+
+    def as_boolean(self):
+        return self.set.as_relational(self.symbol)
+
+
+class ProductContinuousDomain(ProductDomain, ContinuousDomain):
+    """
+    A collection of independent domains with continuous support
+    """
+
+    def compute_expectation(self, expr, variables=None, **kwargs):
+        if variables is None:
+            variables = self.symbols
+        for domain in self.domains:
+            domain_vars = frozenset(variables) & frozenset(domain.symbols)
+            if domain_vars:
+                expr = domain.compute_expectation(expr, domain_vars, **kwargs)
+        return expr
+
+    def as_boolean(self):
+        return And(*[domain.as_boolean() for domain in self.domains])
+
+
+class ConditionalContinuousDomain(ContinuousDomain, ConditionalDomain):
+    """
+    A domain with continuous support that has been further restricted by a
+    condition such as $x > 3$.
+    """
+
+    def compute_expectation(self, expr, variables=None, **kwargs):
+        if variables is None:
+            variables = self.symbols
+        if not variables:
+            return expr
+        # Extract the full integral
+        fullintgrl = self.fulldomain.compute_expectation(expr, variables)
+        # separate into integrand and limits
+        integrand, limits = fullintgrl.function, list(fullintgrl.limits)
+
+        conditions = [self.condition]
+        while conditions:
+            cond = conditions.pop()
+            if cond.is_Boolean:
+                if isinstance(cond, And):
+                    conditions.extend(cond.args)
+                elif isinstance(cond, Or):
+                    raise NotImplementedError("Or not implemented here")
+            elif cond.is_Relational:
+                if cond.is_Equality:
+                    # Add the appropriate Delta to the integrand
+                    integrand *= DiracDelta(cond.lhs - cond.rhs)
+                else:
+                    symbols = cond.free_symbols & set(self.symbols)
+                    if len(symbols) != 1:  # Can't handle x > y
+                        raise NotImplementedError(
+                            "Multivariate Inequalities not yet implemented")
+                    # Can handle x > 0
+                    symbol = symbols.pop()
+                    # Find the limit with x, such as (x, -oo, oo)
+                    for i, limit in enumerate(limits):
+                        if limit[0] == symbol:
+                            # Make condition into an Interval like [0, oo]
+                            cintvl = reduce_rational_inequalities_wrap(
+                                cond, symbol)
+                            # Make limit into an Interval like [-oo, oo]
+                            lintvl = Interval(limit[1], limit[2])
+                            # Intersect them to get [0, oo]
+                            intvl = cintvl.intersect(lintvl)
+                            # Put back into limits list
+                            limits[i] = (symbol, intvl.left, intvl.right)
+            else:
+                raise TypeError(
+                    "Condition %s is not a relational or Boolean" % cond)
+
+        return Integral(integrand, *limits, **kwargs)
+
+    def as_boolean(self):
+        return And(self.fulldomain.as_boolean(), self.condition)
+
+    @property
+    def set(self):
+        if len(self.symbols) == 1:
+            return (self.fulldomain.set & reduce_rational_inequalities_wrap(
+                self.condition, tuple(self.symbols)[0]))
+        else:
+            raise NotImplementedError(
+                "Set of Conditional Domain not Implemented")
+
+
+class ContinuousDistribution(Distribution):
+    def __call__(self, *args):
+        return self.pdf(*args)
+
+
+class SingleContinuousDistribution(ContinuousDistribution, NamedArgsMixin):
+    """ Continuous distribution of a single variable.
+
+    Explanation
+    ===========
+
+    Serves as superclass for Normal/Exponential/UniformDistribution etc....
+
+    Represented by parameters for each of the specific classes.  E.g
+    NormalDistribution is represented by a mean and standard deviation.
+
+    Provides methods for pdf, cdf, and sampling.
+
+    See Also
+    ========
+
+    sympy.stats.crv_types.*
+    """
+
+    set = Interval(-oo, oo)
+
+    def __new__(cls, *args):
+        args = list(map(sympify, args))
+        return Basic.__new__(cls, *args)
+
+    @staticmethod
+    def check(*args):
+        pass
+
+    @cacheit
+    def compute_cdf(self, **kwargs):
+        """ Compute the CDF from the PDF.
+
+        Returns a Lambda.
+        """
+        x, z = symbols('x, z', real=True, cls=Dummy)
+        left_bound = self.set.start
+
+        # CDF is integral of PDF from left bound to z
+        pdf = self.pdf(x)
+        cdf = integrate(pdf.doit(), (x, left_bound, z), **kwargs)
+        # CDF Ensure that CDF left of left_bound is zero
+        cdf = Piecewise((cdf, z >= left_bound), (0, True))
+        return Lambda(z, cdf)
+
+    def _cdf(self, x):
+        return None
+
+    def cdf(self, x, **kwargs):
+        """ Cumulative density function """
+        if len(kwargs) == 0:
+            cdf = self._cdf(x)
+            if cdf is not None:
+                return cdf
+        return self.compute_cdf(**kwargs)(x)
+
+    @cacheit
+    def compute_characteristic_function(self, **kwargs):
+        """ Compute the characteristic function from the PDF.
+
+        Returns a Lambda.
+        """
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        pdf = self.pdf(x)
+        cf = integrate(exp(I*t*x)*pdf, (x, self.set))
+        return Lambda(t, cf)
+
+    def _characteristic_function(self, t):
+        return None
+
+    def characteristic_function(self, t, **kwargs):
+        """ Characteristic function """
+        if len(kwargs) == 0:
+            cf = self._characteristic_function(t)
+            if cf is not None:
+                return cf
+        return self.compute_characteristic_function(**kwargs)(t)
+
+    @cacheit
+    def compute_moment_generating_function(self, **kwargs):
+        """ Compute the moment generating function from the PDF.
+
+        Returns a Lambda.
+        """
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        pdf = self.pdf(x)
+        mgf = integrate(exp(t * x) * pdf, (x, self.set))
+        return Lambda(t, mgf)
+
+    def _moment_generating_function(self, t):
+        return None
+
+    def moment_generating_function(self, t, **kwargs):
+        """ Moment generating function """
+        if not kwargs:
+                mgf = self._moment_generating_function(t)
+                if mgf is not None:
+                    return mgf
+        return self.compute_moment_generating_function(**kwargs)(t)
+
+    def expectation(self, expr, var, evaluate=True, **kwargs):
+        """ Expectation of expression over distribution """
+        if evaluate:
+            try:
+                p = poly(expr, var)
+                if p.is_zero:
+                    return S.Zero
+                t = Dummy('t', real=True)
+                mgf = self._moment_generating_function(t)
+                if mgf is None:
+                    return integrate(expr * self.pdf(var), (var, self.set), **kwargs)
+                deg = p.degree()
+                taylor = poly(series(mgf, t, 0, deg + 1).removeO(), t)
+                result = 0
+                for k in range(deg+1):
+                    result += p.coeff_monomial(var ** k) * taylor.coeff_monomial(t ** k) * factorial(k)
+                return result
+            except PolynomialError:
+                return integrate(expr * self.pdf(var), (var, self.set), **kwargs)
+        else:
+            return Integral(expr * self.pdf(var), (var, self.set), **kwargs)
+
+    @cacheit
+    def compute_quantile(self, **kwargs):
+        """ Compute the Quantile from the PDF.
+
+        Returns a Lambda.
+        """
+        x, p = symbols('x, p', real=True, cls=Dummy)
+        left_bound = self.set.start
+
+        pdf = self.pdf(x)
+        cdf = integrate(pdf, (x, left_bound, x), **kwargs)
+        quantile = solveset(cdf - p, x, self.set)
+        return Lambda(p, Piecewise((quantile, (p >= 0) & (p <= 1) ), (nan, True)))
+
+    def _quantile(self, x):
+        return None
+
+    def quantile(self, x, **kwargs):
+        """ Cumulative density function """
+        if len(kwargs) == 0:
+            quantile = self._quantile(x)
+            if quantile is not None:
+                return quantile
+        return self.compute_quantile(**kwargs)(x)
+
+
+class ContinuousPSpace(PSpace):
+    """ Continuous Probability Space
+
+    Represents the likelihood of an event space defined over a continuum.
+
+    Represented with a ContinuousDomain and a PDF (Lambda-Like)
+    """
+
+    is_Continuous = True
+    is_real = True
+
+    @property
+    def pdf(self):
+        return self.density(*self.domain.symbols)
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        if rvs is None:
+            rvs = self.values
+        else:
+            rvs = frozenset(rvs)
+
+        expr = expr.xreplace({rv: rv.symbol for rv in rvs})
+
+        domain_symbols = frozenset(rv.symbol for rv in rvs)
+
+        return self.domain.compute_expectation(self.pdf * expr,
+                domain_symbols, **kwargs)
+
+    def compute_density(self, expr, **kwargs):
+        # Common case Density(X) where X in self.values
+        if expr in self.values:
+            # Marginalize all other random symbols out of the density
+            randomsymbols = tuple(set(self.values) - frozenset([expr]))
+            symbols = tuple(rs.symbol for rs in randomsymbols)
+            pdf = self.domain.compute_expectation(self.pdf, symbols, **kwargs)
+            return Lambda(expr.symbol, pdf)
+
+        z = Dummy('z', real=True)
+        return Lambda(z, self.compute_expectation(DiracDelta(expr - z), **kwargs))
+
+    @cacheit
+    def compute_cdf(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise ValueError(
+                "CDF not well defined on multivariate expressions")
+
+        d = self.compute_density(expr, **kwargs)
+        x, z = symbols('x, z', real=True, cls=Dummy)
+        left_bound = self.domain.set.start
+
+        # CDF is integral of PDF from left bound to z
+        cdf = integrate(d(x), (x, left_bound, z), **kwargs)
+        # CDF Ensure that CDF left of left_bound is zero
+        cdf = Piecewise((cdf, z >= left_bound), (0, True))
+        return Lambda(z, cdf)
+
+    @cacheit
+    def compute_characteristic_function(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise NotImplementedError("Characteristic function of multivariate expressions not implemented")
+
+        d = self.compute_density(expr, **kwargs)
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        cf = integrate(exp(I*t*x)*d(x), (x, -oo, oo), **kwargs)
+        return Lambda(t, cf)
+
+    @cacheit
+    def compute_moment_generating_function(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise NotImplementedError("Moment generating function of multivariate expressions not implemented")
+
+        d = self.compute_density(expr, **kwargs)
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        mgf = integrate(exp(t * x) * d(x), (x, -oo, oo), **kwargs)
+        return Lambda(t, mgf)
+
+    @cacheit
+    def compute_quantile(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise ValueError(
+                "Quantile not well defined on multivariate expressions")
+
+        d = self.compute_cdf(expr, **kwargs)
+        x = Dummy('x', real=True)
+        p = Dummy('p', positive=True)
+
+        quantile = solveset(d(x) - p, x, self.set)
+
+        return Lambda(p, quantile)
+
+    def probability(self, condition, **kwargs):
+        z = Dummy('z', real=True)
+        cond_inv = False
+        if isinstance(condition, Ne):
+            condition = Eq(condition.args[0], condition.args[1])
+            cond_inv = True
+        # Univariate case can be handled by where
+        try:
+            domain = self.where(condition)
+            rv = [rv for rv in self.values if rv.symbol == domain.symbol][0]
+            # Integrate out all other random variables
+            pdf = self.compute_density(rv, **kwargs)
+            # return S.Zero if `domain` is empty set
+            if domain.set is S.EmptySet or isinstance(domain.set, FiniteSet):
+                return S.Zero if not cond_inv else S.One
+            if isinstance(domain.set, Union):
+                return sum(
+                     Integral(pdf(z), (z, subset), **kwargs) for subset in
+                     domain.set.args if isinstance(subset, Interval))
+            # Integrate out the last variable over the special domain
+            return Integral(pdf(z), (z, domain.set), **kwargs)
+
+        # Other cases can be turned into univariate case
+        # by computing a density handled by density computation
+        except NotImplementedError:
+            from sympy.stats.rv import density
+            expr = condition.lhs - condition.rhs
+            if not is_random(expr):
+                dens = self.density
+                comp = condition.rhs
+            else:
+                dens = density(expr, **kwargs)
+                comp = 0
+            if not isinstance(dens, ContinuousDistribution):
+                from sympy.stats.crv_types import ContinuousDistributionHandmade
+                dens = ContinuousDistributionHandmade(dens, set=self.domain.set)
+            # Turn problem into univariate case
+            space = SingleContinuousPSpace(z, dens)
+            result = space.probability(condition.__class__(space.value, comp))
+            return result if not cond_inv else S.One - result
+
+    def where(self, condition):
+        rvs = frozenset(random_symbols(condition))
+        if not (len(rvs) == 1 and rvs.issubset(self.values)):
+            raise NotImplementedError(
+                "Multiple continuous random variables not supported")
+        rv = tuple(rvs)[0]
+        interval = reduce_rational_inequalities_wrap(condition, rv)
+        interval = interval.intersect(self.domain.set)
+        return SingleContinuousDomain(rv.symbol, interval)
+
+    def conditional_space(self, condition, normalize=True, **kwargs):
+        condition = condition.xreplace({rv: rv.symbol for rv in self.values})
+        domain = ConditionalContinuousDomain(self.domain, condition)
+        if normalize:
+            # create a clone of the variable to
+            # make sure that variables in nested integrals are different
+            # from the variables outside the integral
+            # this makes sure that they are evaluated separately
+            # and in the correct order
+            replacement  = {rv: Dummy(str(rv)) for rv in self.symbols}
+            norm = domain.compute_expectation(self.pdf, **kwargs)
+            pdf = self.pdf / norm.xreplace(replacement)
+            # XXX: Converting set to tuple. The order matters to Lambda though
+            # so we shouldn't be starting with a set here...
+            density = Lambda(tuple(domain.symbols), pdf)
+
+        return ContinuousPSpace(domain, density)
+
+
+class SingleContinuousPSpace(ContinuousPSpace, SinglePSpace):
+    """
+    A continuous probability space over a single univariate variable.
+
+    These consist of a Symbol and a SingleContinuousDistribution
+
+    This class is normally accessed through the various random variable
+    functions, Normal, Exponential, Uniform, etc....
+    """
+
+    @property
+    def set(self):
+        return self.distribution.set
+
+    @property
+    def domain(self):
+        return SingleContinuousDomain(sympify(self.symbol), self.set)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method.
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+        return {self.value: self.distribution.sample(size, library=library, seed=seed)}
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        rvs = rvs or (self.value,)
+        if self.value not in rvs:
+            return expr
+
+        expr = _sympify(expr)
+        expr = expr.xreplace({rv: rv.symbol for rv in rvs})
+
+        x = self.value.symbol
+        try:
+            return self.distribution.expectation(expr, x, evaluate=evaluate, **kwargs)
+        except PoleError:
+            return Integral(expr * self.pdf, (x, self.set), **kwargs)
+
+    def compute_cdf(self, expr, **kwargs):
+        if expr == self.value:
+            z = Dummy("z", real=True)
+            return Lambda(z, self.distribution.cdf(z, **kwargs))
+        else:
+            return ContinuousPSpace.compute_cdf(self, expr, **kwargs)
+
+    def compute_characteristic_function(self, expr, **kwargs):
+        if expr == self.value:
+            t = Dummy("t", real=True)
+            return Lambda(t, self.distribution.characteristic_function(t, **kwargs))
+        else:
+            return ContinuousPSpace.compute_characteristic_function(self, expr, **kwargs)
+
+    def compute_moment_generating_function(self, expr, **kwargs):
+        if expr == self.value:
+            t = Dummy("t", real=True)
+            return Lambda(t, self.distribution.moment_generating_function(t, **kwargs))
+        else:
+            return ContinuousPSpace.compute_moment_generating_function(self, expr, **kwargs)
+
+    def compute_density(self, expr, **kwargs):
+        # https://en.wikipedia.org/wiki/Random_variable#Functions_of_random_variables
+        if expr == self.value:
+            return self.density
+        y = Dummy('y', real=True)
+
+        gs = solveset(expr - y, self.value, S.Reals)
+
+        if isinstance(gs, Intersection) and S.Reals in gs.args:
+            gs = list(gs.args[1])
+
+        if not gs:
+            raise ValueError("Can not solve %s for %s"%(expr, self.value))
+        fx = self.compute_density(self.value)
+        fy = sum(fx(g) * abs(g.diff(y)) for g in gs)
+        return Lambda(y, fy)
+
+    def compute_quantile(self, expr, **kwargs):
+
+        if expr == self.value:
+            p = Dummy("p", real=True)
+            return Lambda(p, self.distribution.quantile(p, **kwargs))
+        else:
+            return ContinuousPSpace.compute_quantile(self, expr, **kwargs)
+
+def _reduce_inequalities(conditions, var, **kwargs):
+    try:
+        return reduce_rational_inequalities(conditions, var, **kwargs)
+    except PolynomialError:
+        raise ValueError("Reduction of condition failed %s\n" % conditions[0])
+
+
+def reduce_rational_inequalities_wrap(condition, var):
+    if condition.is_Relational:
+        return _reduce_inequalities([[condition]], var, relational=False)
+    if isinstance(condition, Or):
+        return Union(*[_reduce_inequalities([[arg]], var, relational=False)
+            for arg in condition.args])
+    if isinstance(condition, And):
+        intervals = [_reduce_inequalities([[arg]], var, relational=False)
+            for arg in condition.args]
+        I = intervals[0]
+        for i in intervals:
+            I = I.intersect(i)
+        return I

venv/lib/python3.10/site-packages/sympy/stats/drv.py

@@ -0,0 +1,350 @@
+from sympy.concrete.summations import (Sum, summation)
+from sympy.core.basic import Basic
+from sympy.core.cache import cacheit
+from sympy.core.function import Lambda
+from sympy.core.numbers import I
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import And
+from sympy.polys.polytools import poly
+from sympy.series.series import series
+
+from sympy.polys.polyerrors import PolynomialError
+from sympy.stats.crv import reduce_rational_inequalities_wrap
+from sympy.stats.rv import (NamedArgsMixin, SinglePSpace, SingleDomain,
+                            random_symbols, PSpace, ConditionalDomain, RandomDomain,
+                            ProductDomain, Distribution)
+from sympy.stats.symbolic_probability import Probability
+from sympy.sets.fancysets import Range, FiniteSet
+from sympy.sets.sets import Union
+from sympy.sets.contains import Contains
+from sympy.utilities import filldedent
+from sympy.core.sympify import _sympify
+
+
+class DiscreteDistribution(Distribution):
+    def __call__(self, *args):
+        return self.pdf(*args)
+
+
+class SingleDiscreteDistribution(DiscreteDistribution, NamedArgsMixin):
+    """ Discrete distribution of a single variable.
+
+    Serves as superclass for PoissonDistribution etc....
+
+    Provides methods for pdf, cdf, and sampling
+
+    See Also:
+        sympy.stats.crv_types.*
+    """
+
+    set = S.Integers
+
+    def __new__(cls, *args):
+        args = list(map(sympify, args))
+        return Basic.__new__(cls, *args)
+
+    @staticmethod
+    def check(*args):
+        pass
+
+    @cacheit
+    def compute_cdf(self, **kwargs):
+        """ Compute the CDF from the PDF.
+
+        Returns a Lambda.
+        """
+        x = symbols('x', integer=True, cls=Dummy)
+        z = symbols('z', real=True, cls=Dummy)
+        left_bound = self.set.inf
+
+        # CDF is integral of PDF from left bound to z
+        pdf = self.pdf(x)
+        cdf = summation(pdf, (x, left_bound, floor(z)), **kwargs)
+        # CDF Ensure that CDF left of left_bound is zero
+        cdf = Piecewise((cdf, z >= left_bound), (0, True))
+        return Lambda(z, cdf)
+
+    def _cdf(self, x):
+        return None
+
+    def cdf(self, x, **kwargs):
+        """ Cumulative density function """
+        if not kwargs:
+            cdf = self._cdf(x)
+            if cdf is not None:
+                return cdf
+        return self.compute_cdf(**kwargs)(x)
+
+    @cacheit
+    def compute_characteristic_function(self, **kwargs):
+        """ Compute the characteristic function from the PDF.
+
+        Returns a Lambda.
+        """
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        pdf = self.pdf(x)
+        cf = summation(exp(I*t*x)*pdf, (x, self.set.inf, self.set.sup))
+        return Lambda(t, cf)
+
+    def _characteristic_function(self, t):
+        return None
+
+    def characteristic_function(self, t, **kwargs):
+        """ Characteristic function """
+        if not kwargs:
+            cf = self._characteristic_function(t)
+            if cf is not None:
+                return cf
+        return self.compute_characteristic_function(**kwargs)(t)
+
+    @cacheit
+    def compute_moment_generating_function(self, **kwargs):
+        t = Dummy('t', real=True)
+        x = Dummy('x', integer=True)
+        pdf = self.pdf(x)
+        mgf = summation(exp(t*x)*pdf, (x, self.set.inf, self.set.sup))
+        return Lambda(t, mgf)
+
+    def _moment_generating_function(self, t):
+        return None
+
+    def moment_generating_function(self, t, **kwargs):
+        if not kwargs:
+            mgf = self._moment_generating_function(t)
+            if mgf is not None:
+                return mgf
+        return self.compute_moment_generating_function(**kwargs)(t)
+
+    @cacheit
+    def compute_quantile(self, **kwargs):
+        """ Compute the Quantile from the PDF.
+
+        Returns a Lambda.
+        """
+        x = Dummy('x', integer=True)
+        p = Dummy('p', real=True)
+        left_bound = self.set.inf
+        pdf = self.pdf(x)
+        cdf = summation(pdf, (x, left_bound, x), **kwargs)
+        set = ((x, p <= cdf), )
+        return Lambda(p, Piecewise(*set))
+
+    def _quantile(self, x):
+        return None
+
+    def quantile(self, x, **kwargs):
+        """ Cumulative density function """
+        if not kwargs:
+            quantile = self._quantile(x)
+            if quantile is not None:
+                return quantile
+        return self.compute_quantile(**kwargs)(x)
+
+    def expectation(self, expr, var, evaluate=True, **kwargs):
+        """ Expectation of expression over distribution """
+        # TODO: support discrete sets with non integer stepsizes
+
+        if evaluate:
+            try:
+                p = poly(expr, var)
+
+                t = Dummy('t', real=True)
+
+                mgf = self.moment_generating_function(t)
+                deg = p.degree()
+                taylor = poly(series(mgf, t, 0, deg + 1).removeO(), t)
+                result = 0
+                for k in range(deg+1):
+                    result += p.coeff_monomial(var ** k) * taylor.coeff_monomial(t ** k) * factorial(k)
+
+                return result
+
+            except PolynomialError:
+                return summation(expr * self.pdf(var),
+                                 (var, self.set.inf, self.set.sup), **kwargs)
+
+        else:
+            return Sum(expr * self.pdf(var),
+                         (var, self.set.inf, self.set.sup), **kwargs)
+
+    def __call__(self, *args):
+        return self.pdf(*args)
+
+
+class DiscreteDomain(RandomDomain):
+    """
+    A domain with discrete support with step size one.
+    Represented using symbols and Range.
+    """
+    is_Discrete = True
+
+class SingleDiscreteDomain(DiscreteDomain, SingleDomain):
+    def as_boolean(self):
+        return Contains(self.symbol, self.set)
+
+
+class ConditionalDiscreteDomain(DiscreteDomain, ConditionalDomain):
+    """
+    Domain with discrete support of step size one, that is restricted by
+    some condition.
+    """
+    @property
+    def set(self):
+        rv = self.symbols
+        if len(self.symbols) > 1:
+            raise NotImplementedError(filldedent('''
+                Multivariate conditional domains are not yet implemented.'''))
+        rv = list(rv)[0]
+        return reduce_rational_inequalities_wrap(self.condition,
+            rv).intersect(self.fulldomain.set)
+
+
+class DiscretePSpace(PSpace):
+    is_real = True
+    is_Discrete = True
+
+    @property
+    def pdf(self):
+        return self.density(*self.symbols)
+
+    def where(self, condition):
+        rvs = random_symbols(condition)
+        assert all(r.symbol in self.symbols for r in rvs)
+        if len(rvs) > 1:
+            raise NotImplementedError(filldedent('''Multivariate discrete
+            random variables are not yet supported.'''))
+        conditional_domain = reduce_rational_inequalities_wrap(condition,
+            rvs[0])
+        conditional_domain = conditional_domain.intersect(self.domain.set)
+        return SingleDiscreteDomain(rvs[0].symbol, conditional_domain)
+
+    def probability(self, condition):
+        complement = isinstance(condition, Ne)
+        if complement:
+            condition = Eq(condition.args[0], condition.args[1])
+        try:
+            _domain = self.where(condition).set
+            if condition == False or _domain is S.EmptySet:
+                return S.Zero
+            if condition == True or _domain == self.domain.set:
+                return S.One
+            prob = self.eval_prob(_domain)
+        except NotImplementedError:
+            from sympy.stats.rv import density
+            expr = condition.lhs - condition.rhs
+            dens = density(expr)
+            if not isinstance(dens, DiscreteDistribution):
+                from sympy.stats.drv_types import DiscreteDistributionHandmade
+                dens = DiscreteDistributionHandmade(dens)
+            z = Dummy('z', real=True)
+            space = SingleDiscretePSpace(z, dens)
+            prob = space.probability(condition.__class__(space.value, 0))
+        if prob is None:
+            prob = Probability(condition)
+        return prob if not complement else S.One - prob
+
+    def eval_prob(self, _domain):
+        sym = list(self.symbols)[0]
+        if isinstance(_domain, Range):
+            n = symbols('n', integer=True)
+            inf, sup, step = (r for r in _domain.args)
+            summand = ((self.pdf).replace(
+              sym, n*step))
+            rv = summation(summand,
+                (n, inf/step, (sup)/step - 1)).doit()
+            return rv
+        elif isinstance(_domain, FiniteSet):
+            pdf = Lambda(sym, self.pdf)
+            rv = sum(pdf(x) for x in _domain)
+            return rv
+        elif isinstance(_domain, Union):
+            rv = sum(self.eval_prob(x) for x in _domain.args)
+            return rv
+
+    def conditional_space(self, condition):
+        # XXX: Converting from set to tuple. The order matters to Lambda
+        # though so we should be starting with a set...
+        density = Lambda(tuple(self.symbols), self.pdf/self.probability(condition))
+        condition = condition.xreplace({rv: rv.symbol for rv in self.values})
+        domain = ConditionalDiscreteDomain(self.domain, condition)
+        return DiscretePSpace(domain, density)
+
+class ProductDiscreteDomain(ProductDomain, DiscreteDomain):
+     def as_boolean(self):
+        return And(*[domain.as_boolean for domain in self.domains])
+
+class SingleDiscretePSpace(DiscretePSpace, SinglePSpace):
+    """ Discrete probability space over a single univariate variable """
+    is_real = True
+
+    @property
+    def set(self):
+        return self.distribution.set
+
+    @property
+    def domain(self):
+        return SingleDiscreteDomain(self.symbol, self.set)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method.
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+        return {self.value: self.distribution.sample(size, library=library, seed=seed)}
+
+    def compute_expectation(self, expr, rvs=None, evaluate=True, **kwargs):
+        rvs = rvs or (self.value,)
+        if self.value not in rvs:
+            return expr
+
+        expr = _sympify(expr)
+        expr = expr.xreplace({rv: rv.symbol for rv in rvs})
+
+        x = self.value.symbol
+        try:
+            return self.distribution.expectation(expr, x, evaluate=evaluate,
+                    **kwargs)
+        except NotImplementedError:
+            return Sum(expr * self.pdf, (x, self.set.inf, self.set.sup),
+                    **kwargs)
+
+    def compute_cdf(self, expr, **kwargs):
+        if expr == self.value:
+            x = Dummy("x", real=True)
+            return Lambda(x, self.distribution.cdf(x, **kwargs))
+        else:
+            raise NotImplementedError()
+
+    def compute_density(self, expr, **kwargs):
+        if expr == self.value:
+            return self.distribution
+        raise NotImplementedError()
+
+    def compute_characteristic_function(self, expr, **kwargs):
+        if expr == self.value:
+            t = Dummy("t", real=True)
+            return Lambda(t, self.distribution.characteristic_function(t, **kwargs))
+        else:
+            raise NotImplementedError()
+
+    def compute_moment_generating_function(self, expr, **kwargs):
+        if expr == self.value:
+            t = Dummy("t", real=True)
+            return Lambda(t, self.distribution.moment_generating_function(t, **kwargs))
+        else:
+            raise NotImplementedError()
+
+    def compute_quantile(self, expr, **kwargs):
+        if expr == self.value:
+            p = Dummy("p", real=True)
+            return Lambda(p, self.distribution.quantile(p, **kwargs))
+        else:
+            raise NotImplementedError()

venv/lib/python3.10/site-packages/sympy/stats/drv_types.py

@@ -0,0 +1,835 @@
+"""
+
+Contains
+========
+FlorySchulz
+Geometric
+Hermite
+Logarithmic
+NegativeBinomial
+Poisson
+Skellam
+YuleSimon
+Zeta
+"""
+
+
+
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.zeta_functions import (polylog, zeta)
+from sympy.stats.drv import SingleDiscreteDistribution, SingleDiscretePSpace
+from sympy.stats.rv import _value_check, is_random
+
+
+__all__ = ['FlorySchulz',
+'Geometric',
+'Hermite',
+'Logarithmic',
+'NegativeBinomial',
+'Poisson',
+'Skellam',
+'YuleSimon',
+'Zeta'
+]
+
+
+def rv(symbol, cls, *args, **kwargs):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    if kwargs.pop('check', True):
+        dist.check(*args)
+    pspace = SingleDiscretePSpace(symbol, dist)
+    if any(is_random(arg) for arg in args):
+        from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
+        pspace = CompoundPSpace(symbol, CompoundDistribution(dist))
+    return pspace.value
+
+
+class DiscreteDistributionHandmade(SingleDiscreteDistribution):
+    _argnames = ('pdf',)
+
+    def __new__(cls, pdf, set=S.Integers):
+        return Basic.__new__(cls, pdf, set)
+
+    @property
+    def set(self):
+        return self.args[1]
+
+    @staticmethod
+    def check(pdf, set):
+        x = Dummy('x')
+        val = Sum(pdf(x), (x, set._inf, set._sup)).doit()
+        _value_check(Eq(val, 1) != S.false, "The pdf is incorrect on the given set.")
+
+
+
+def DiscreteRV(symbol, density, set=S.Integers, **kwargs):
+    """
+    Create a Discrete Random Variable given the following:
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        Represents name of the random variable.
+    density : Expression containing symbol
+        Represents probability density function.
+    set : set
+        Represents the region where the pdf is valid, by default is real line.
+    check : bool
+        If True, it will check whether the given density
+        integrates to 1 over the given set. If False, it
+        will not perform this check. Default is False.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import DiscreteRV, P, E
+    >>> from sympy import Rational, Symbol
+    >>> x = Symbol('x')
+    >>> n = 10
+    >>> density = Rational(1, 10)
+    >>> X = DiscreteRV(x, density, set=set(range(n)))
+    >>> E(X)
+    9/2
+    >>> P(X>3)
+    3/5
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    set = sympify(set)
+    pdf = Piecewise((density, set.as_relational(symbol)), (0, True))
+    pdf = Lambda(symbol, pdf)
+    # have a default of False while `rv` should have a default of True
+    kwargs['check'] = kwargs.pop('check', False)
+    return rv(symbol.name, DiscreteDistributionHandmade, pdf, set, **kwargs)
+
+
+#-------------------------------------------------------------------------------
+# Flory-Schulz distribution ------------------------------------------------------------
+
+class FlorySchulzDistribution(SingleDiscreteDistribution):
+    _argnames = ('a',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(a):
+        _value_check((0 < a, a < 1), "a must be between 0 and 1")
+
+    def pdf(self, k):
+        a = self.a
+        return (a**2 * k * (1 - a)**(k - 1))
+
+    def _characteristic_function(self, t):
+        a = self.a
+        return a**2*exp(I*t)/((1 + (a - 1)*exp(I*t))**2)
+
+    def _moment_generating_function(self, t):
+        a = self.a
+        return a**2*exp(t)/((1 + (a - 1)*exp(t))**2)
+
+
+def FlorySchulz(name, a):
+    r"""
+    Create a discrete random variable with a FlorySchulz distribution.
+
+    The density of the FlorySchulz distribution is given by
+
+    .. math::
+        f(k) := (a^2) k (1 - a)^{k-1}
+
+    Parameters
+    ==========
+
+    a : A real number between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, E, variance, FlorySchulz
+    >>> from sympy import Symbol, S
+
+    >>> a = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = FlorySchulz("x", a)
+
+    >>> density(X)(z)
+    (5/4)**(1 - z)*z/25
+
+    >>> E(X)
+    9
+
+    >>> variance(X)
+    40
+
+    References
+    ==========
+
+    https://en.wikipedia.org/wiki/Flory%E2%80%93Schulz_distribution
+    """
+    return rv(name, FlorySchulzDistribution, a)
+
+
+#-------------------------------------------------------------------------------
+# Geometric distribution ------------------------------------------------------------
+
+class GeometricDistribution(SingleDiscreteDistribution):
+    _argnames = ('p',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(p):
+        _value_check((0 < p, p <= 1), "p must be between 0 and 1")
+
+    def pdf(self, k):
+        return (1 - self.p)**(k - 1) * self.p
+
+    def _characteristic_function(self, t):
+        p = self.p
+        return p * exp(I*t) / (1 - (1 - p)*exp(I*t))
+
+    def _moment_generating_function(self, t):
+        p = self.p
+        return p * exp(t) / (1 - (1 - p) * exp(t))
+
+
+def Geometric(name, p):
+    r"""
+    Create a discrete random variable with a Geometric distribution.
+
+    Explanation
+    ===========
+
+    The density of the Geometric distribution is given by
+
+    .. math::
+        f(k) := p (1 - p)^{k - 1}
+
+    Parameters
+    ==========
+
+    p : A probability between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Geometric, density, E, variance
+    >>> from sympy import Symbol, S
+
+    >>> p = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = Geometric("x", p)
+
+    >>> density(X)(z)
+    (5/4)**(1 - z)/5
+
+    >>> E(X)
+    5
+
+    >>> variance(X)
+    20
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Geometric_distribution
+    .. [2] https://mathworld.wolfram.com/GeometricDistribution.html
+
+    """
+    return rv(name, GeometricDistribution, p)
+
+
+#-------------------------------------------------------------------------------
+# Hermite distribution ---------------------------------------------------------
+
+
+class HermiteDistribution(SingleDiscreteDistribution):
+    _argnames = ('a1', 'a2')
+    set = S.Naturals0
+
+    @staticmethod
+    def check(a1, a2):
+        _value_check(a1.is_nonnegative, 'Parameter a1 must be >= 0.')
+        _value_check(a2.is_nonnegative, 'Parameter a2 must be >= 0.')
+
+    def pdf(self, k):
+        a1, a2 = self.a1, self.a2
+        term1 = exp(-(a1 + a2))
+        j = Dummy("j", integer=True)
+        num = a1**(k - 2*j) * a2**j
+        den = factorial(k - 2*j) * factorial(j)
+        return term1 * Sum(num/den, (j, 0, k//2)).doit()
+
+    def _moment_generating_function(self, t):
+        a1, a2 = self.a1, self.a2
+        term1 = a1 * (exp(t) - 1)
+        term2 = a2 * (exp(2*t) - 1)
+        return exp(term1 + term2)
+
+    def _characteristic_function(self, t):
+        a1, a2 = self.a1, self.a2
+        term1 = a1 * (exp(I*t) - 1)
+        term2 = a2 * (exp(2*I*t) - 1)
+        return exp(term1 + term2)
+
+def Hermite(name, a1, a2):
+    r"""
+    Create a discrete random variable with a Hermite distribution.
+
+    Explanation
+    ===========
+
+    The density of the Hermite distribution is given by
+
+    .. math::
+        f(x):= e^{-a_1 -a_2}\sum_{j=0}^{\left \lfloor x/2 \right \rfloor}
+                    \frac{a_{1}^{x-2j}a_{2}^{j}}{(x-2j)!j!}
+
+    Parameters
+    ==========
+
+    a1 : A Positive number greater than equal to 0.
+    a2 : A Positive number greater than equal to 0.
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Hermite, density, E, variance
+    >>> from sympy import Symbol
+
+    >>> a1 = Symbol("a1", positive=True)
+    >>> a2 = Symbol("a2", positive=True)
+    >>> x = Symbol("x")
+
+    >>> H = Hermite("H", a1=5, a2=4)
+
+    >>> density(H)(2)
+    33*exp(-9)/2
+
+    >>> E(H)
+    13
+
+    >>> variance(H)
+    21
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermite_distribution
+
+    """
+
+    return rv(name, HermiteDistribution, a1, a2)
+
+
+#-------------------------------------------------------------------------------
+# Logarithmic distribution ------------------------------------------------------------
+
+class LogarithmicDistribution(SingleDiscreteDistribution):
+    _argnames = ('p',)
+
+    set = S.Naturals
+
+    @staticmethod
+    def check(p):
+        _value_check((p > 0, p < 1), "p should be between 0 and 1")
+
+    def pdf(self, k):
+        p = self.p
+        return (-1) * p**k / (k * log(1 - p))
+
+    def _characteristic_function(self, t):
+        p = self.p
+        return log(1 - p * exp(I*t)) / log(1 - p)
+
+    def _moment_generating_function(self, t):
+        p = self.p
+        return log(1 - p * exp(t)) / log(1 - p)
+
+
+def Logarithmic(name, p):
+    r"""
+    Create a discrete random variable with a Logarithmic distribution.
+
+    Explanation
+    ===========
+
+    The density of the Logarithmic distribution is given by
+
+    .. math::
+        f(k) := \frac{-p^k}{k \ln{(1 - p)}}
+
+    Parameters
+    ==========
+
+    p : A value between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Logarithmic, density, E, variance
+    >>> from sympy import Symbol, S
+
+    >>> p = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = Logarithmic("x", p)
+
+    >>> density(X)(z)
+    -1/(5**z*z*log(4/5))
+
+    >>> E(X)
+    -1/(-4*log(5) + 8*log(2))
+
+    >>> variance(X)
+    -1/((-4*log(5) + 8*log(2))*(-2*log(5) + 4*log(2))) + 1/(-64*log(2)*log(5) + 64*log(2)**2 + 16*log(5)**2) - 10/(-32*log(5) + 64*log(2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Logarithmic_distribution
+    .. [2] https://mathworld.wolfram.com/LogarithmicDistribution.html
+
+    """
+    return rv(name, LogarithmicDistribution, p)
+
+
+#-------------------------------------------------------------------------------
+# Negative binomial distribution ------------------------------------------------------------
+
+class NegativeBinomialDistribution(SingleDiscreteDistribution):
+    _argnames = ('r', 'p')
+    set = S.Naturals0
+
+    @staticmethod
+    def check(r, p):
+        _value_check(r > 0, 'r should be positive')
+        _value_check((p > 0, p < 1), 'p should be between 0 and 1')
+
+    def pdf(self, k):
+        r = self.r
+        p = self.p
+
+        return binomial(k + r - 1, k) * (1 - p)**r * p**k
+
+    def _characteristic_function(self, t):
+        r = self.r
+        p = self.p
+
+        return ((1 - p) / (1 - p * exp(I*t)))**r
+
+    def _moment_generating_function(self, t):
+        r = self.r
+        p = self.p
+
+        return ((1 - p) / (1 - p * exp(t)))**r
+
+def NegativeBinomial(name, r, p):
+    r"""
+    Create a discrete random variable with a Negative Binomial distribution.
+
+    Explanation
+    ===========
+
+    The density of the Negative Binomial distribution is given by
+
+    .. math::
+        f(k) := \binom{k + r - 1}{k} (1 - p)^r p^k
+
+    Parameters
+    ==========
+
+    r : A positive value
+    p : A value between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import NegativeBinomial, density, E, variance
+    >>> from sympy import Symbol, S
+
+    >>> r = 5
+    >>> p = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = NegativeBinomial("x", r, p)
+
+    >>> density(X)(z)
+    1024*binomial(z + 4, z)/(3125*5**z)
+
+    >>> E(X)
+    5/4
+
+    >>> variance(X)
+    25/16
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Negative_binomial_distribution
+    .. [2] https://mathworld.wolfram.com/NegativeBinomialDistribution.html
+
+    """
+    return rv(name, NegativeBinomialDistribution, r, p)
+
+
+#-------------------------------------------------------------------------------
+# Poisson distribution ------------------------------------------------------------
+
+class PoissonDistribution(SingleDiscreteDistribution):
+    _argnames = ('lamda',)
+
+    set = S.Naturals0
+
+    @staticmethod
+    def check(lamda):
+        _value_check(lamda > 0, "Lambda must be positive")
+
+    def pdf(self, k):
+        return self.lamda**k / factorial(k) * exp(-self.lamda)
+
+    def _characteristic_function(self, t):
+        return exp(self.lamda * (exp(I*t) - 1))
+
+    def _moment_generating_function(self, t):
+        return exp(self.lamda * (exp(t) - 1))
+
+
+def Poisson(name, lamda):
+    r"""
+    Create a discrete random variable with a Poisson distribution.
+
+    Explanation
+    ===========
+
+    The density of the Poisson distribution is given by
+
+    .. math::
+        f(k) := \frac{\lambda^{k} e^{- \lambda}}{k!}
+
+    Parameters
+    ==========
+
+    lamda : Positive number, a rate
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Poisson, density, E, variance
+    >>> from sympy import Symbol, simplify
+
+    >>> rate = Symbol("lambda", positive=True)
+    >>> z = Symbol("z")
+
+    >>> X = Poisson("x", rate)
+
+    >>> density(X)(z)
+    lambda**z*exp(-lambda)/factorial(z)
+
+    >>> E(X)
+    lambda
+
+    >>> simplify(variance(X))
+    lambda
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Poisson_distribution
+    .. [2] https://mathworld.wolfram.com/PoissonDistribution.html
+
+    """
+    return rv(name, PoissonDistribution, lamda)
+
+
+# -----------------------------------------------------------------------------
+# Skellam distribution --------------------------------------------------------
+
+
+class SkellamDistribution(SingleDiscreteDistribution):
+    _argnames = ('mu1', 'mu2')
+    set = S.Integers
+
+    @staticmethod
+    def check(mu1, mu2):
+        _value_check(mu1 >= 0, 'Parameter mu1 must be >= 0')
+        _value_check(mu2 >= 0, 'Parameter mu2 must be >= 0')
+
+    def pdf(self, k):
+        (mu1, mu2) = (self.mu1, self.mu2)
+        term1 = exp(-(mu1 + mu2)) * (mu1 / mu2) ** (k / 2)
+        term2 = besseli(k, 2 * sqrt(mu1 * mu2))
+        return term1 * term2
+
+    def _cdf(self, x):
+        raise NotImplementedError(
+            "Skellam doesn't have closed form for the CDF.")
+
+    def _characteristic_function(self, t):
+        (mu1, mu2) = (self.mu1, self.mu2)
+        return exp(-(mu1 + mu2) + mu1 * exp(I * t) + mu2 * exp(-I * t))
+
+    def _moment_generating_function(self, t):
+        (mu1, mu2) = (self.mu1, self.mu2)
+        return exp(-(mu1 + mu2) + mu1 * exp(t) + mu2 * exp(-t))
+
+
+def Skellam(name, mu1, mu2):
+    r"""
+    Create a discrete random variable with a Skellam distribution.
+
+    Explanation
+    ===========
+
+    The Skellam is the distribution of the difference N1 - N2
+    of two statistically independent random variables N1 and N2
+    each Poisson-distributed with respective expected values mu1 and mu2.
+
+    The density of the Skellam distribution is given by
+
+    .. math::
+        f(k) := e^{-(\mu_1+\mu_2)}(\frac{\mu_1}{\mu_2})^{k/2}I_k(2\sqrt{\mu_1\mu_2})
+
+    Parameters
+    ==========
+
+    mu1 : A non-negative value
+    mu2 : A non-negative value
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Skellam, density, E, variance
+    >>> from sympy import Symbol, pprint
+
+    >>> z = Symbol("z", integer=True)
+    >>> mu1 = Symbol("mu1", positive=True)
+    >>> mu2 = Symbol("mu2", positive=True)
+    >>> X = Skellam("x", mu1, mu2)
+
+    >>> pprint(density(X)(z), use_unicode=False)
+         z
+         -
+         2
+    /mu1\   -mu1 - mu2        /       _____   _____\
+    |---| *e          *besseli\z, 2*\/ mu1 *\/ mu2 /
+    \mu2/
+    >>> E(X)
+    mu1 - mu2
+    >>> variance(X).expand()
+    mu1 + mu2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Skellam_distribution
+
+    """
+    return rv(name, SkellamDistribution, mu1, mu2)
+
+
+#-------------------------------------------------------------------------------
+# Yule-Simon distribution ------------------------------------------------------------
+
+class YuleSimonDistribution(SingleDiscreteDistribution):
+    _argnames = ('rho',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(rho):
+        _value_check(rho > 0, 'rho should be positive')
+
+    def pdf(self, k):
+        rho = self.rho
+        return rho * beta(k, rho + 1)
+
+    def _cdf(self, x):
+        return Piecewise((1 - floor(x) * beta(floor(x), self.rho + 1), x >= 1), (0, True))
+
+    def _characteristic_function(self, t):
+        rho = self.rho
+        return rho * hyper((1, 1), (rho + 2,), exp(I*t)) * exp(I*t) / (rho + 1)
+
+    def _moment_generating_function(self, t):
+        rho = self.rho
+        return rho * hyper((1, 1), (rho + 2,), exp(t)) * exp(t) / (rho + 1)
+
+
+def YuleSimon(name, rho):
+    r"""
+    Create a discrete random variable with a Yule-Simon distribution.
+
+    Explanation
+    ===========
+
+    The density of the Yule-Simon distribution is given by
+
+    .. math::
+        f(k) := \rho B(k, \rho + 1)
+
+    Parameters
+    ==========
+
+    rho : A positive value
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import YuleSimon, density, E, variance
+    >>> from sympy import Symbol, simplify
+
+    >>> p = 5
+    >>> z = Symbol("z")
+
+    >>> X = YuleSimon("x", p)
+
+    >>> density(X)(z)
+    5*beta(z, 6)
+
+    >>> simplify(E(X))
+    5/4
+
+    >>> simplify(variance(X))
+    25/48
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Yule%E2%80%93Simon_distribution
+
+    """
+    return rv(name, YuleSimonDistribution, rho)
+
+
+#-------------------------------------------------------------------------------
+# Zeta distribution ------------------------------------------------------------
+
+class ZetaDistribution(SingleDiscreteDistribution):
+    _argnames = ('s',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(s):
+        _value_check(s > 1, 's should be greater than 1')
+
+    def pdf(self, k):
+        s = self.s
+        return 1 / (k**s * zeta(s))
+
+    def _characteristic_function(self, t):
+        return polylog(self.s, exp(I*t)) / zeta(self.s)
+
+    def _moment_generating_function(self, t):
+        return polylog(self.s, exp(t)) / zeta(self.s)
+
+
+def Zeta(name, s):
+    r"""
+    Create a discrete random variable with a Zeta distribution.
+
+    Explanation
+    ===========
+
+    The density of the Zeta distribution is given by
+
+    .. math::
+        f(k) := \frac{1}{k^s \zeta{(s)}}
+
+    Parameters
+    ==========
+
+    s : A value greater than 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Zeta, density, E, variance
+    >>> from sympy import Symbol
+
+    >>> s = 5
+    >>> z = Symbol("z")
+
+    >>> X = Zeta("x", s)
+
+    >>> density(X)(z)
+    1/(z**5*zeta(5))
+
+    >>> E(X)
+    pi**4/(90*zeta(5))
+
+    >>> variance(X)
+    -pi**8/(8100*zeta(5)**2) + zeta(3)/zeta(5)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Zeta_distribution
+
+    """
+    return rv(name, ZetaDistribution, s)

venv/lib/python3.10/site-packages/sympy/stats/error_prop.py

@@ -0,0 +1,100 @@
+"""Tools for arithmetic error propagation."""
+
+from itertools import repeat, combinations
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.simplify.simplify import simplify
+from sympy.stats.symbolic_probability import RandomSymbol, Variance, Covariance
+from sympy.stats.rv import is_random
+
+_arg0_or_var = lambda var: var.args[0] if len(var.args) > 0 else var
+
+
+def variance_prop(expr, consts=(), include_covar=False):
+    r"""Symbolically propagates variance (`\sigma^2`) for expressions.
+    This is computed as as seen in [1]_.
+
+    Parameters
+    ==========
+
+    expr : Expr
+        A SymPy expression to compute the variance for.
+    consts : sequence of Symbols, optional
+        Represents symbols that are known constants in the expr,
+        and thus have zero variance. All symbols not in consts are
+        assumed to be variant.
+    include_covar : bool, optional
+        Flag for whether or not to include covariances, default=False.
+
+    Returns
+    =======
+
+    var_expr : Expr
+        An expression for the total variance of the expr.
+        The variance for the original symbols (e.g. x) are represented
+        via instance of the Variance symbol (e.g. Variance(x)).
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, exp
+    >>> from sympy.stats.error_prop import variance_prop
+    >>> x, y = symbols('x y')
+
+    >>> variance_prop(x + y)
+    Variance(x) + Variance(y)
+
+    >>> variance_prop(x * y)
+    x**2*Variance(y) + y**2*Variance(x)
+
+    >>> variance_prop(exp(2*x))
+    4*exp(4*x)*Variance(x)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Propagation_of_uncertainty
+
+    """
+    args = expr.args
+    if len(args) == 0:
+        if expr in consts:
+            return S.Zero
+        elif is_random(expr):
+            return Variance(expr).doit()
+        elif isinstance(expr, Symbol):
+            return Variance(RandomSymbol(expr)).doit()
+        else:
+            return S.Zero
+    nargs = len(args)
+    var_args = list(map(variance_prop, args, repeat(consts, nargs),
+                        repeat(include_covar, nargs)))
+    if isinstance(expr, Add):
+        var_expr = Add(*var_args)
+        if include_covar:
+            terms = [2 * Covariance(_arg0_or_var(x), _arg0_or_var(y)).expand() \
+                     for x, y in combinations(var_args, 2)]
+            var_expr += Add(*terms)
+    elif isinstance(expr, Mul):
+        terms = [v/a**2 for a, v in zip(args, var_args)]
+        var_expr = simplify(expr**2 * Add(*terms))
+        if include_covar:
+            terms = [2*Covariance(_arg0_or_var(x), _arg0_or_var(y)).expand()/(a*b) \
+                     for (a, b), (x, y) in zip(combinations(args, 2),
+                                               combinations(var_args, 2))]
+            var_expr += Add(*terms)
+    elif isinstance(expr, Pow):
+        b = args[1]
+        v = var_args[0] * (expr * b / args[0])**2
+        var_expr = simplify(v)
+    elif isinstance(expr, exp):
+        var_expr = simplify(var_args[0] * expr**2)
+    else:
+        # unknown how to proceed, return variance of whole expr.
+        var_expr = Variance(expr)
+    return var_expr

venv/lib/python3.10/site-packages/sympy/stats/frv.py

@@ -0,0 +1,512 @@
+"""
+Finite Discrete Random Variables Module
+
+See Also
+========
+sympy.stats.frv_types
+sympy.stats.rv
+sympy.stats.crv
+"""
+from itertools import product
+
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.cache import cacheit
+from sympy.core.function import Lambda
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, nan)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import (And, Or)
+from sympy.sets.sets import Intersection
+from sympy.core.containers import Dict
+from sympy.core.logic import Logic
+from sympy.core.relational import Relational
+from sympy.core.sympify import _sympify
+from sympy.sets.sets import FiniteSet
+from sympy.stats.rv import (RandomDomain, ProductDomain, ConditionalDomain,
+                            PSpace, IndependentProductPSpace, SinglePSpace, random_symbols,
+                            sumsets, rv_subs, NamedArgsMixin, Density, Distribution)
+
+
+class FiniteDensity(dict):
+    """
+    A domain with Finite Density.
+    """
+    def __call__(self, item):
+        """
+        Make instance of a class callable.
+
+        If item belongs to current instance of a class, return it.
+
+        Otherwise, return 0.
+        """
+        item = sympify(item)
+        if item in self:
+            return self[item]
+        else:
+            return 0
+
+    @property
+    def dict(self):
+        """
+        Return item as dictionary.
+        """
+        return dict(self)
+
+class FiniteDomain(RandomDomain):
+    """
+    A domain with discrete finite support
+
+    Represented using a FiniteSet.
+    """
+    is_Finite = True
+
+    @property
+    def symbols(self):
+        return FiniteSet(sym for sym, val in self.elements)
+
+    @property
+    def elements(self):
+        return self.args[0]
+
+    @property
+    def dict(self):
+        return FiniteSet(*[Dict(dict(el)) for el in self.elements])
+
+    def __contains__(self, other):
+        return other in self.elements
+
+    def __iter__(self):
+        return self.elements.__iter__()
+
+    def as_boolean(self):
+        return Or(*[And(*[Eq(sym, val) for sym, val in item]) for item in self])
+
+
+class SingleFiniteDomain(FiniteDomain):
+    """
+    A FiniteDomain over a single symbol/set
+
+    Example: The possibilities of a *single* die roll.
+    """
+
+    def __new__(cls, symbol, set):
+        if not isinstance(set, FiniteSet) and \
+            not isinstance(set, Intersection):
+            set = FiniteSet(*set)
+        return Basic.__new__(cls, symbol, set)
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def symbols(self):
+        return FiniteSet(self.symbol)
+
+    @property
+    def set(self):
+        return self.args[1]
+
+    @property
+    def elements(self):
+        return FiniteSet(*[frozenset(((self.symbol, elem), )) for elem in self.set])
+
+    def __iter__(self):
+        return (frozenset(((self.symbol, elem),)) for elem in self.set)
+
+    def __contains__(self, other):
+        sym, val = tuple(other)[0]
+        return sym == self.symbol and val in self.set
+
+
+class ProductFiniteDomain(ProductDomain, FiniteDomain):
+    """
+    A Finite domain consisting of several other FiniteDomains
+
+    Example: The possibilities of the rolls of three independent dice
+    """
+
+    def __iter__(self):
+        proditer = product(*self.domains)
+        return (sumsets(items) for items in proditer)
+
+    @property
+    def elements(self):
+        return FiniteSet(*self)
+
+
+class ConditionalFiniteDomain(ConditionalDomain, ProductFiniteDomain):
+    """
+    A FiniteDomain that has been restricted by a condition
+
+    Example: The possibilities of a die roll under the condition that the
+    roll is even.
+    """
+
+    def __new__(cls, domain, condition):
+        """
+        Create a new instance of ConditionalFiniteDomain class
+        """
+        if condition is True:
+            return domain
+        cond = rv_subs(condition)
+        return Basic.__new__(cls, domain, cond)
+
+    def _test(self, elem):
+        """
+        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.
+        """
+        val = self.condition.xreplace(dict(elem))
+        if val in [True, False]:
+            return val
+        elif val.is_Equality:
+            return val.lhs == val.rhs
+        raise ValueError("Undecidable if %s" % str(val))
+
+    def __contains__(self, other):
+        return other in self.fulldomain and self._test(other)
+
+    def __iter__(self):
+        return (elem for elem in self.fulldomain if self._test(elem))
+
+    @property
+    def set(self):
+        if isinstance(self.fulldomain, SingleFiniteDomain):
+            return FiniteSet(*[elem for elem in self.fulldomain.set
+                               if frozenset(((self.fulldomain.symbol, elem),)) in self])
+        else:
+            raise NotImplementedError(
+                "Not implemented on multi-dimensional conditional domain")
+
+    def as_boolean(self):
+        return FiniteDomain.as_boolean(self)
+
+
+class SingleFiniteDistribution(Distribution, NamedArgsMixin):
+    def __new__(cls, *args):
+        args = list(map(sympify, args))
+        return Basic.__new__(cls, *args)
+
+    @staticmethod
+    def check(*args):
+        pass
+
+    @property # type: ignore
+    @cacheit
+    def dict(self):
+        if self.is_symbolic:
+            return Density(self)
+        return {k: self.pmf(k) for k in self.set}
+
+    def pmf(self, *args): # to be overridden by specific distribution
+        raise NotImplementedError()
+
+    @property
+    def set(self): # to be overridden by specific distribution
+        raise NotImplementedError()
+
+    values = property(lambda self: self.dict.values)
+    items = property(lambda self: self.dict.items)
+    is_symbolic = property(lambda self: False)
+    __iter__ = property(lambda self: self.dict.__iter__)
+    __getitem__ = property(lambda self: self.dict.__getitem__)
+
+    def __call__(self, *args):
+        return self.pmf(*args)
+
+    def __contains__(self, other):
+        return other in self.set
+
+
+#=============================================
+#=========  Probability Space  ===============
+#=============================================
+
+
+class FinitePSpace(PSpace):
+    """
+    A Finite Probability Space
+
+    Represents the probabilities of a finite number of events.
+    """
+    is_Finite = True
+
+    def __new__(cls, domain, density):
+        density = {sympify(key): sympify(val)
+                for key, val in density.items()}
+        public_density = Dict(density)
+
+        obj = PSpace.__new__(cls, domain, public_density)
+        obj._density = density
+        return obj
+
+    def prob_of(self, elem):
+        elem = sympify(elem)
+        density = self._density
+        if isinstance(list(density.keys())[0], FiniteSet):
+            return density.get(elem, S.Zero)
+        return density.get(tuple(elem)[0][1], S.Zero)
+
+    def where(self, condition):
+        assert all(r.symbol in self.symbols for r in random_symbols(condition))
+        return ConditionalFiniteDomain(self.domain, condition)
+
+    def compute_density(self, expr):
+        expr = rv_subs(expr, self.values)
+        d = FiniteDensity()
+        for elem in self.domain:
+            val = expr.xreplace(dict(elem))
+            prob = self.prob_of(elem)
+            d[val] = d.get(val, S.Zero) + prob
+        return d
+
+    @cacheit
+    def compute_cdf(self, expr):
+        d = self.compute_density(expr)
+        cum_prob = S.Zero
+        cdf = []
+        for key in sorted(d):
+            prob = d[key]
+            cum_prob += prob
+            cdf.append((key, cum_prob))
+
+        return dict(cdf)
+
+    @cacheit
+    def sorted_cdf(self, expr, python_float=False):
+        cdf = self.compute_cdf(expr)
+        items = list(cdf.items())
+        sorted_items = sorted(items, key=lambda val_cumprob: val_cumprob[1])
+        if python_float:
+            sorted_items = [(v, float(cum_prob))
+                    for v, cum_prob in sorted_items]
+        return sorted_items
+
+    @cacheit
+    def compute_characteristic_function(self, expr):
+        d = self.compute_density(expr)
+        t = Dummy('t', real=True)
+
+        return Lambda(t, sum(exp(I*k*t)*v for k,v in d.items()))
+
+    @cacheit
+    def compute_moment_generating_function(self, expr):
+        d = self.compute_density(expr)
+        t = Dummy('t', real=True)
+
+        return Lambda(t, sum(exp(k*t)*v for k,v in d.items()))
+
+    def compute_expectation(self, expr, rvs=None, **kwargs):
+        rvs = rvs or self.values
+        expr = rv_subs(expr, rvs)
+        probs = [self.prob_of(elem) for elem in self.domain]
+        if isinstance(expr, (Logic, Relational)):
+            parse_domain = [tuple(elem)[0][1] for elem in self.domain]
+            bools = [expr.xreplace(dict(elem)) for elem in self.domain]
+        else:
+            parse_domain = [expr.xreplace(dict(elem)) for elem in self.domain]
+            bools = [True for elem in self.domain]
+        return sum([Piecewise((prob * elem, blv), (S.Zero, True))
+                for prob, elem, blv in zip(probs, parse_domain, bools)])
+
+    def compute_quantile(self, expr):
+        cdf = self.compute_cdf(expr)
+        p = Dummy('p', real=True)
+        set = ((nan, (p < 0) | (p > 1)),)
+        for key, value in cdf.items():
+            set = set + ((key, p <= value), )
+        return Lambda(p, Piecewise(*set))
+
+    def probability(self, condition):
+        cond_symbols = frozenset(rs.symbol for rs in random_symbols(condition))
+        cond = rv_subs(condition)
+        if not cond_symbols.issubset(self.symbols):
+            raise ValueError("Cannot compare foreign random symbols, %s"
+                             %(str(cond_symbols - self.symbols)))
+        if isinstance(condition, Relational) and \
+            (not cond.free_symbols.issubset(self.domain.free_symbols)):
+            rv = condition.lhs if isinstance(condition.rhs, Symbol) else condition.rhs
+            return sum(Piecewise(
+                       (self.prob_of(elem), condition.subs(rv, list(elem)[0][1])),
+                       (S.Zero, True)) for elem in self.domain)
+        return sympify(sum(self.prob_of(elem) for elem in self.where(condition)))
+
+    def conditional_space(self, condition):
+        domain = self.where(condition)
+        prob = self.probability(condition)
+        density = {key: val / prob
+                for key, val in self._density.items() if domain._test(key)}
+        return FinitePSpace(domain, density)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+        return {self.value: self.distribution.sample(size, library, seed)}
+
+
+class SingleFinitePSpace(SinglePSpace, FinitePSpace):
+    """
+    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....
+    """
+    @property
+    def domain(self):
+        return SingleFiniteDomain(self.symbol, self.distribution.set)
+
+    @property
+    def _is_symbolic(self):
+        """
+        Helper property to check if the distribution
+        of the random variable is having symbolic
+        dimension.
+        """
+        return self.distribution.is_symbolic
+
+    @property
+    def distribution(self):
+        return self.args[1]
+
+    def pmf(self, expr):
+        return self.distribution.pmf(expr)
+
+    @property # type: ignore
+    @cacheit
+    def _density(self):
+        return {FiniteSet((self.symbol, val)): prob
+                    for val, prob in self.distribution.dict.items()}
+
+    @cacheit
+    def compute_characteristic_function(self, expr):
+        if self._is_symbolic:
+            d = self.compute_density(expr)
+            t = Dummy('t', real=True)
+            ki = Dummy('ki')
+            return Lambda(t, Sum(d(ki)*exp(I*ki*t), (ki, self.args[1].low, self.args[1].high)))
+        expr = rv_subs(expr, self.values)
+        return FinitePSpace(self.domain, self.distribution).compute_characteristic_function(expr)
+
+    @cacheit
+    def compute_moment_generating_function(self, expr):
+        if self._is_symbolic:
+            d = self.compute_density(expr)
+            t = Dummy('t', real=True)
+            ki = Dummy('ki')
+            return Lambda(t, Sum(d(ki)*exp(ki*t), (ki, self.args[1].low, self.args[1].high)))
+        expr = rv_subs(expr, self.values)
+        return FinitePSpace(self.domain, self.distribution).compute_moment_generating_function(expr)
+
+    def compute_quantile(self, expr):
+        if self._is_symbolic:
+            raise NotImplementedError("Computing quantile for random variables "
+            "with symbolic dimension because the bounds of searching the required "
+            "value is undetermined.")
+        expr = rv_subs(expr, self.values)
+        return FinitePSpace(self.domain, self.distribution).compute_quantile(expr)
+
+    def compute_density(self, expr):
+        if self._is_symbolic:
+            rv = list(random_symbols(expr))[0]
+            k = Dummy('k', integer=True)
+            cond = True if not isinstance(expr, (Relational, Logic)) \
+                     else expr.subs(rv, k)
+            return Lambda(k,
+            Piecewise((self.pmf(k), And(k >= self.args[1].low,
+            k <= self.args[1].high, cond)), (S.Zero, True)))
+        expr = rv_subs(expr, self.values)
+        return FinitePSpace(self.domain, self.distribution).compute_density(expr)
+
+    def compute_cdf(self, expr):
+        if self._is_symbolic:
+            d = self.compute_density(expr)
+            k = Dummy('k')
+            ki = Dummy('ki')
+            return Lambda(k, Sum(d(ki), (ki, self.args[1].low, k)))
+        expr = rv_subs(expr, self.values)
+        return FinitePSpace(self.domain, self.distribution).compute_cdf(expr)
+
+    def compute_expectation(self, expr, rvs=None, **kwargs):
+        if self._is_symbolic:
+            rv = random_symbols(expr)[0]
+            k = Dummy('k', integer=True)
+            expr = expr.subs(rv, k)
+            cond = True if not isinstance(expr, (Relational, Logic)) \
+                    else expr
+            func = self.pmf(k) * k if cond != True else self.pmf(k) * expr
+            return Sum(Piecewise((func, cond), (S.Zero, True)),
+                (k, self.distribution.low, self.distribution.high)).doit()
+
+        expr = _sympify(expr)
+        expr = rv_subs(expr, rvs)
+        return FinitePSpace(self.domain, self.distribution).compute_expectation(expr, rvs, **kwargs)
+
+    def probability(self, condition):
+        if self._is_symbolic:
+            #TODO: Implement the mechanism for handling queries for symbolic sized distributions.
+            raise NotImplementedError("Currently, probability queries are not "
+            "supported for random variables with symbolic sized distributions.")
+        condition = rv_subs(condition)
+        return FinitePSpace(self.domain, self.distribution).probability(condition)
+
+    def conditional_space(self, condition):
+        """
+        This method is used for transferring the
+        computation to probability method because
+        conditional space of random variables with
+        symbolic dimensions is currently not possible.
+        """
+        if self._is_symbolic:
+            self
+        domain = self.where(condition)
+        prob = self.probability(condition)
+        density = {key: val / prob
+                for key, val in self._density.items() if domain._test(key)}
+        return FinitePSpace(domain, density)
+
+
+class ProductFinitePSpace(IndependentProductPSpace, FinitePSpace):
+    """
+    A collection of several independent finite probability spaces
+    """
+    @property
+    def domain(self):
+        return ProductFiniteDomain(*[space.domain for space in self.spaces])
+
+    @property  # type: ignore
+    @cacheit
+    def _density(self):
+        proditer = product(*[iter(space._density.items())
+            for space in self.spaces])
+        d = {}
+        for items in proditer:
+            elems, probs = list(zip(*items))
+            elem = sumsets(elems)
+            prob = Mul(*probs)
+            d[elem] = d.get(elem, S.Zero) + prob
+        return Dict(d)
+
+    @property  # type: ignore
+    @cacheit
+    def density(self):
+        return Dict(self._density)
+
+    def probability(self, condition):
+        return FinitePSpace.probability(self, condition)
+
+    def compute_density(self, expr):
+        return FinitePSpace.compute_density(self, expr)

venv/lib/python3.10/site-packages/sympy/stats/frv_types.py

@@ -0,0 +1,870 @@
+"""
+Finite Discrete Random Variables - Prebuilt variable types
+
+Contains
+========
+FiniteRV
+DiscreteUniform
+Die
+Bernoulli
+Coin
+Binomial
+BetaBinomial
+Hypergeometric
+Rademacher
+IdealSoliton
+RobustSoliton
+"""
+
+
+from sympy.core.cache import cacheit
+from sympy.core.function import Lambda
+from sympy.core.numbers import (Integer, Rational)
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import Or
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (Intersection, Interval)
+from sympy.functions.special.beta_functions import beta as beta_fn
+from sympy.stats.frv import (SingleFiniteDistribution,
+                             SingleFinitePSpace)
+from sympy.stats.rv import _value_check, Density, is_random
+from sympy.utilities.iterables import multiset
+from sympy.utilities.misc import filldedent
+
+
+__all__ = ['FiniteRV',
+'DiscreteUniform',
+'Die',
+'Bernoulli',
+'Coin',
+'Binomial',
+'BetaBinomial',
+'Hypergeometric',
+'Rademacher',
+'IdealSoliton',
+'RobustSoliton',
+]
+
+def rv(name, cls, *args, **kwargs):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    if kwargs.pop('check', True):
+        dist.check(*args)
+    pspace = SingleFinitePSpace(name, dist)
+    if any(is_random(arg) for arg in args):
+        from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
+        pspace = CompoundPSpace(name, CompoundDistribution(dist))
+    return pspace.value
+
+class FiniteDistributionHandmade(SingleFiniteDistribution):
+
+    @property
+    def dict(self):
+        return self.args[0]
+
+    def pmf(self, x):
+        x = Symbol('x')
+        return Lambda(x, Piecewise(*(
+            [(v, Eq(k, x)) for k, v in self.dict.items()] + [(S.Zero, True)])))
+
+    @property
+    def set(self):
+        return set(self.dict.keys())
+
+    @staticmethod
+    def check(density):
+        for p in density.values():
+            _value_check((p >= 0, p <= 1),
+                        "Probability at a point must be between 0 and 1.")
+        val = sum(density.values())
+        _value_check(Eq(val, 1) != S.false, "Total Probability must be 1.")
+
+def FiniteRV(name, density, **kwargs):
+    r"""
+    Create a Finite Random Variable given a dict representing the density.
+
+    Parameters
+    ==========
+
+    name : Symbol
+        Represents name of the random variable.
+    density : dict
+        Dictionary containing the pdf of finite distribution
+    check : bool
+        If True, it will check whether the given density
+        integrates to 1 over the given set. If False, it
+        will not perform this check. Default is False.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import FiniteRV, P, E
+
+    >>> density = {0: .1, 1: .2, 2: .3, 3: .4}
+    >>> X = FiniteRV('X', density)
+
+    >>> E(X)
+    2.00000000000000
+    >>> P(X >= 2)
+    0.700000000000000
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    # have a default of False while `rv` should have a default of True
+    kwargs['check'] = kwargs.pop('check', False)
+    return rv(name, FiniteDistributionHandmade, density, **kwargs)
+
+class DiscreteUniformDistribution(SingleFiniteDistribution):
+
+    @staticmethod
+    def check(*args):
+        # not using _value_check since there is a
+        # suggestion for the user
+        if len(set(args)) != len(args):
+            weights = multiset(args)
+            n = Integer(len(args))
+            for k in weights:
+                weights[k] /= n
+            raise ValueError(filldedent("""
+                Repeated args detected but set expected. For a
+                distribution having different weights for each
+                item use the following:""") + (
+                '\nS("FiniteRV(%s, %s)")' % ("'X'", weights)))
+
+    @property
+    def p(self):
+        return Rational(1, len(self.args))
+
+    @property  # type: ignore
+    @cacheit
+    def dict(self):
+        return {k: self.p for k in self.set}
+
+    @property
+    def set(self):
+        return set(self.args)
+
+    def pmf(self, x):
+        if x in self.args:
+            return self.p
+        else:
+            return S.Zero
+
+
+def DiscreteUniform(name, items):
+    r"""
+    Create a Finite Random Variable representing a uniform distribution over
+    the input set.
+
+    Parameters
+    ==========
+
+    items : list/tuple
+        Items over which Uniform distribution is to be made
+
+    Examples
+    ========
+
+    >>> from sympy.stats import DiscreteUniform, density
+    >>> from sympy import symbols
+
+    >>> X = DiscreteUniform('X', symbols('a b c')) # equally likely over a, b, c
+    >>> density(X).dict
+    {a: 1/3, b: 1/3, c: 1/3}
+
+    >>> Y = DiscreteUniform('Y', list(range(5))) # distribution over a range
+    >>> density(Y).dict
+    {0: 1/5, 1: 1/5, 2: 1/5, 3: 1/5, 4: 1/5}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Discrete_uniform_distribution
+    .. [2] https://mathworld.wolfram.com/DiscreteUniformDistribution.html
+
+    """
+    return rv(name, DiscreteUniformDistribution, *items)
+
+
+class DieDistribution(SingleFiniteDistribution):
+    _argnames = ('sides',)
+
+    @staticmethod
+    def check(sides):
+        _value_check((sides.is_positive, sides.is_integer),
+                    "number of sides must be a positive integer.")
+
+    @property
+    def is_symbolic(self):
+        return not self.sides.is_number
+
+    @property
+    def high(self):
+        return self.sides
+
+    @property
+    def low(self):
+        return S.One
+
+    @property
+    def set(self):
+        if self.is_symbolic:
+            return Intersection(S.Naturals0, Interval(0, self.sides))
+        return set(map(Integer, range(1, self.sides + 1)))
+
+    def pmf(self, x):
+        x = sympify(x)
+        if not (x.is_number or x.is_Symbol or is_random(x)):
+            raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or "
+                        "'RandomSymbol' not %s" % (type(x)))
+        cond = Ge(x, 1) & Le(x, self.sides) & Contains(x, S.Integers)
+        return Piecewise((S.One/self.sides, cond), (S.Zero, True))
+
+def Die(name, sides=6):
+    r"""
+    Create a Finite Random Variable representing a fair die.
+
+    Parameters
+    ==========
+
+    sides : Integer
+        Represents the number of sides of the Die, by default is 6
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Die, density
+    >>> from sympy import Symbol
+
+    >>> D6 = Die('D6', 6) # Six sided Die
+    >>> density(D6).dict
+    {1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
+
+    >>> D4 = Die('D4', 4) # Four sided Die
+    >>> density(D4).dict
+    {1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
+
+    >>> n = Symbol('n', positive=True, integer=True)
+    >>> Dn = Die('Dn', n) # n sided Die
+    >>> density(Dn).dict
+    Density(DieDistribution(n))
+    >>> density(Dn).dict.subs(n, 4).doit()
+    {1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
+
+    Returns
+    =======
+
+    RandomSymbol
+    """
+
+    return rv(name, DieDistribution, sides)
+
+
+class BernoulliDistribution(SingleFiniteDistribution):
+    _argnames = ('p', 'succ', 'fail')
+
+    @staticmethod
+    def check(p, succ, fail):
+        _value_check((p >= 0, p <= 1),
+                    "p should be in range [0, 1].")
+
+    @property
+    def set(self):
+        return {self.succ, self.fail}
+
+    def pmf(self, x):
+        if isinstance(self.succ, Symbol) and isinstance(self.fail, Symbol):
+            return Piecewise((self.p, x == self.succ),
+                             (1 - self.p, x == self.fail),
+                             (S.Zero, True))
+        return Piecewise((self.p, Eq(x, self.succ)),
+                         (1 - self.p, Eq(x, self.fail)),
+                         (S.Zero, True))
+
+
+def Bernoulli(name, p, succ=1, fail=0):
+    r"""
+    Create a Finite Random Variable representing a Bernoulli process.
+
+    Parameters
+    ==========
+
+    p : Rational number between 0 and 1
+       Represents probability of success
+    succ : Integer/symbol/string
+       Represents event of success
+    fail : Integer/symbol/string
+       Represents event of failure
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Bernoulli, density
+    >>> from sympy import S
+
+    >>> X = Bernoulli('X', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4
+    >>> density(X).dict
+    {0: 1/4, 1: 3/4}
+
+    >>> X = Bernoulli('X', S.Half, 'Heads', 'Tails') # A fair coin toss
+    >>> density(X).dict
+    {Heads: 1/2, Tails: 1/2}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bernoulli_distribution
+    .. [2] https://mathworld.wolfram.com/BernoulliDistribution.html
+
+    """
+
+    return rv(name, BernoulliDistribution, p, succ, fail)
+
+
+def Coin(name, p=S.Half):
+    r"""
+    Create a Finite Random Variable representing a Coin toss.
+
+    Parameters
+    ==========
+
+    p : Rational Number between 0 and 1
+      Represents probability of getting "Heads", by default is Half
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Coin, density
+    >>> from sympy import Rational
+
+    >>> C = Coin('C') # A fair coin toss
+    >>> density(C).dict
+    {H: 1/2, T: 1/2}
+
+    >>> C2 = Coin('C2', Rational(3, 5)) # An unfair coin
+    >>> density(C2).dict
+    {H: 3/5, T: 2/5}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    See Also
+    ========
+
+    sympy.stats.Binomial
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Coin_flipping
+
+    """
+    return rv(name, BernoulliDistribution, p, 'H', 'T')
+
+
+class BinomialDistribution(SingleFiniteDistribution):
+    _argnames = ('n', 'p', 'succ', 'fail')
+
+    @staticmethod
+    def check(n, p, succ, fail):
+        _value_check((n.is_integer, n.is_nonnegative),
+                    "'n' must be nonnegative integer.")
+        _value_check((p <= 1, p >= 0),
+                    "p should be in range [0, 1].")
+
+    @property
+    def high(self):
+        return self.n
+
+    @property
+    def low(self):
+        return S.Zero
+
+    @property
+    def is_symbolic(self):
+        return not self.n.is_number
+
+    @property
+    def set(self):
+        if self.is_symbolic:
+            return Intersection(S.Naturals0, Interval(0, self.n))
+        return set(self.dict.keys())
+
+    def pmf(self, x):
+        n, p = self.n, self.p
+        x = sympify(x)
+        if not (x.is_number or x.is_Symbol or is_random(x)):
+            raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or "
+                        "'RandomSymbol' not %s" % (type(x)))
+        cond = Ge(x, 0) & Le(x, n) & Contains(x, S.Integers)
+        return Piecewise((binomial(n, x) * p**x * (1 - p)**(n - x), cond), (S.Zero, True))
+
+    @property  # type: ignore
+    @cacheit
+    def dict(self):
+        if self.is_symbolic:
+            return Density(self)
+        return {k*self.succ + (self.n-k)*self.fail: self.pmf(k)
+                    for k in range(0, self.n + 1)}
+
+
+def Binomial(name, n, p, succ=1, fail=0):
+    r"""
+    Create a Finite Random Variable representing a binomial distribution.
+
+    Parameters
+    ==========
+
+    n : Positive Integer
+      Represents number of trials
+    p : Rational Number between 0 and 1
+      Represents probability of success
+    succ : Integer/symbol/string
+      Represents event of success, by default is 1
+    fail : Integer/symbol/string
+      Represents event of failure, by default is 0
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Binomial, density
+    >>> from sympy import S, Symbol
+
+    >>> X = Binomial('X', 4, S.Half) # Four "coin flips"
+    >>> density(X).dict
+    {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
+
+    >>> n = Symbol('n', positive=True, integer=True)
+    >>> p = Symbol('p', positive=True)
+    >>> X = Binomial('X', n, S.Half) # n "coin flips"
+    >>> density(X).dict
+    Density(BinomialDistribution(n, 1/2, 1, 0))
+    >>> density(X).dict.subs(n, 4).doit()
+    {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Binomial_distribution
+    .. [2] https://mathworld.wolfram.com/BinomialDistribution.html
+
+    """
+
+    return rv(name, BinomialDistribution, n, p, succ, fail)
+
+#-------------------------------------------------------------------------------
+# Beta-binomial distribution ----------------------------------------------------------
+
+class BetaBinomialDistribution(SingleFiniteDistribution):
+    _argnames = ('n', 'alpha', 'beta')
+
+    @staticmethod
+    def check(n, alpha, beta):
+        _value_check((n.is_integer, n.is_nonnegative),
+        "'n' must be nonnegative integer. n = %s." % str(n))
+        _value_check((alpha > 0),
+        "'alpha' must be: alpha > 0 . alpha = %s" % str(alpha))
+        _value_check((beta > 0),
+        "'beta' must be: beta > 0 . beta = %s" % str(beta))
+
+    @property
+    def high(self):
+        return self.n
+
+    @property
+    def low(self):
+        return S.Zero
+
+    @property
+    def is_symbolic(self):
+        return not self.n.is_number
+
+    @property
+    def set(self):
+        if self.is_symbolic:
+            return Intersection(S.Naturals0, Interval(0, self.n))
+        return set(map(Integer, range(self.n + 1)))
+
+    def pmf(self, k):
+        n, a, b = self.n, self.alpha, self.beta
+        return binomial(n, k) * beta_fn(k + a, n - k + b) / beta_fn(a, b)
+
+
+def BetaBinomial(name, n, alpha, beta):
+    r"""
+    Create a Finite Random Variable representing a Beta-binomial distribution.
+
+    Parameters
+    ==========
+
+    n : Positive Integer
+      Represents number of trials
+    alpha : Real positive number
+    beta : Real positive number
+
+    Examples
+    ========
+
+    >>> from sympy.stats import BetaBinomial, density
+
+    >>> X = BetaBinomial('X', 2, 1, 1)
+    >>> density(X).dict
+    {0: 1/3, 1: 2*beta(2, 2), 2: 1/3}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution
+    .. [2] https://mathworld.wolfram.com/BetaBinomialDistribution.html
+
+    """
+
+    return rv(name, BetaBinomialDistribution, n, alpha, beta)
+
+
+class HypergeometricDistribution(SingleFiniteDistribution):
+    _argnames = ('N', 'm', 'n')
+
+    @staticmethod
+    def check(n, N, m):
+        _value_check((N.is_integer, N.is_nonnegative),
+                     "'N' must be nonnegative integer. N = %s." % str(n))
+        _value_check((n.is_integer, n.is_nonnegative),
+                     "'n' must be nonnegative integer. n = %s." % str(n))
+        _value_check((m.is_integer, m.is_nonnegative),
+                     "'m' must be nonnegative integer. m = %s." % str(n))
+
+    @property
+    def is_symbolic(self):
+        return not all(x.is_number for x in (self.N, self.m, self.n))
+
+    @property
+    def high(self):
+        return Piecewise((self.n, Lt(self.n, self.m) != False), (self.m, True))
+
+    @property
+    def low(self):
+        return Piecewise((0, Gt(0, self.n + self.m - self.N) != False), (self.n + self.m - self.N, True))
+
+    @property
+    def set(self):
+        N, m, n = self.N, self.m, self.n
+        if self.is_symbolic:
+            return Intersection(S.Naturals0, Interval(self.low, self.high))
+        return set(range(max(0, n + m - N), min(n, m) + 1))
+
+    def pmf(self, k):
+        N, m, n = self.N, self.m, self.n
+        return S(binomial(m, k) * binomial(N - m, n - k))/binomial(N, n)
+
+
+def Hypergeometric(name, N, m, n):
+    r"""
+    Create a Finite Random Variable representing a hypergeometric distribution.
+
+    Parameters
+    ==========
+
+    N : Positive Integer
+      Represents finite population of size N.
+    m : Positive Integer
+      Represents number of trials with required feature.
+    n : Positive Integer
+      Represents numbers of draws.
+
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Hypergeometric, density
+
+    >>> X = Hypergeometric('X', 10, 5, 3) # 10 marbles, 5 white (success), 3 draws
+    >>> density(X).dict
+    {0: 1/12, 1: 5/12, 2: 5/12, 3: 1/12}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hypergeometric_distribution
+    .. [2] https://mathworld.wolfram.com/HypergeometricDistribution.html
+
+    """
+    return rv(name, HypergeometricDistribution, N, m, n)
+
+
+class RademacherDistribution(SingleFiniteDistribution):
+
+    @property
+    def set(self):
+        return {-1, 1}
+
+    @property
+    def pmf(self):
+        k = Dummy('k')
+        return Lambda(k, Piecewise((S.Half, Or(Eq(k, -1), Eq(k, 1))), (S.Zero, True)))
+
+def Rademacher(name):
+    r"""
+    Create a Finite Random Variable representing a Rademacher distribution.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Rademacher, density
+
+    >>> X = Rademacher('X')
+    >>> density(X).dict
+    {-1: 1/2, 1: 1/2}
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    See Also
+    ========
+
+    sympy.stats.Bernoulli
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Rademacher_distribution
+
+    """
+    return rv(name, RademacherDistribution)
+
+class IdealSolitonDistribution(SingleFiniteDistribution):
+    _argnames = ('k',)
+
+    @staticmethod
+    def check(k):
+         _value_check(k.is_integer and k.is_positive,
+                    "'k' must be a positive integer.")
+
+    @property
+    def low(self):
+        return S.One
+
+    @property
+    def high(self):
+        return self.k
+
+    @property
+    def set(self):
+        return set(map(Integer, range(1, self.k + 1)))
+
+    @property # type: ignore
+    @cacheit
+    def dict(self):
+        if self.k.is_Symbol:
+            return Density(self)
+        d = {1: Rational(1, self.k)}
+        d.update({i: Rational(1, i*(i - 1)) for i in range(2, self.k + 1)})
+        return d
+
+    def pmf(self, x):
+        x = sympify(x)
+        if not (x.is_number or x.is_Symbol or is_random(x)):
+            raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or "
+                        "'RandomSymbol' not %s" % (type(x)))
+        cond1 = Eq(x, 1) & x.is_integer
+        cond2 = Ge(x, 1) & Le(x, self.k) & x.is_integer
+        return Piecewise((1/self.k, cond1), (1/(x*(x - 1)), cond2), (S.Zero, True))
+
+def IdealSoliton(name, k):
+    r"""
+    Create a Finite Random Variable of Ideal Soliton Distribution
+
+    Parameters
+    ==========
+
+    k : Positive Integer
+        Represents the number of input symbols in an LT (Luby Transform) code.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import IdealSoliton, density, P, E
+    >>> sol = IdealSoliton('sol', 5)
+    >>> density(sol).dict
+    {1: 1/5, 2: 1/2, 3: 1/6, 4: 1/12, 5: 1/20}
+    >>> density(sol).set
+    {1, 2, 3, 4, 5}
+
+    >>> from sympy import Symbol
+    >>> k = Symbol('k', positive=True, integer=True)
+    >>> sol = IdealSoliton('sol', k)
+    >>> density(sol).dict
+    Density(IdealSolitonDistribution(k))
+    >>> density(sol).dict.subs(k, 10).doit()
+    {1: 1/10, 2: 1/2, 3: 1/6, 4: 1/12, 5: 1/20, 6: 1/30, 7: 1/42, 8: 1/56, 9: 1/72, 10: 1/90}
+
+    >>> E(sol.subs(k, 10))
+    7381/2520
+
+    >>> P(sol.subs(k, 4) > 2)
+    1/4
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Soliton_distribution#Ideal_distribution
+    .. [2] https://pages.cs.wisc.edu/~suman/courses/740/papers/luby02lt.pdf
+
+    """
+    return rv(name, IdealSolitonDistribution, k)
+
+class RobustSolitonDistribution(SingleFiniteDistribution):
+    _argnames= ('k', 'delta', 'c')
+
+    @staticmethod
+    def check(k, delta, c):
+        _value_check(k.is_integer and k.is_positive,
+                    "'k' must be a positive integer")
+        _value_check(Gt(delta, 0) and Le(delta, 1),
+                    "'delta' must be a real number in the interval (0,1)")
+        _value_check(c.is_positive,
+                    "'c' must be a positive real number.")
+
+    @property
+    def R(self):
+        return self.c * log(self.k/self.delta) * self.k**0.5
+
+    @property
+    def Z(self):
+        z = 0
+        for i in Range(1, round(self.k/self.R)):
+            z += (1/i)
+        z += log(self.R/self.delta)
+        return 1 + z * self.R/self.k
+
+    @property
+    def low(self):
+        return S.One
+
+    @property
+    def high(self):
+        return self.k
+
+    @property
+    def set(self):
+        return set(map(Integer, range(1, self.k + 1)))
+
+    @property
+    def is_symbolic(self):
+        return not (self.k.is_number and self.c.is_number and self.delta.is_number)
+
+    def pmf(self, x):
+        x = sympify(x)
+        if not (x.is_number or x.is_Symbol or is_random(x)):
+            raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or "
+                        "'RandomSymbol' not %s" % (type(x)))
+
+        cond1 = Eq(x, 1) & x.is_integer
+        cond2 = Ge(x, 1) & Le(x, self.k) & x.is_integer
+        rho = Piecewise((Rational(1, self.k), cond1), (Rational(1, x*(x-1)), cond2), (S.Zero, True))
+
+        cond1 = Ge(x, 1) & Le(x, round(self.k/self.R)-1)
+        cond2 = Eq(x, round(self.k/self.R))
+        tau = Piecewise((self.R/(self.k * x), cond1), (self.R * log(self.R/self.delta)/self.k, cond2), (S.Zero, True))
+
+        return (rho + tau)/self.Z
+
+def RobustSoliton(name, k, delta, c):
+    r'''
+    Create a Finite Random Variable of Robust Soliton Distribution
+
+    Parameters
+    ==========
+
+    k : Positive Integer
+        Represents the number of input symbols in an LT (Luby Transform) code.
+    delta : Positive Rational Number
+            Represents the failure probability. Must be in the interval (0,1).
+    c : Positive Rational Number
+        Constant of proportionality. Values close to 1 are recommended
+
+    Examples
+    ========
+
+    >>> from sympy.stats import RobustSoliton, density, P, E
+    >>> robSol = RobustSoliton('robSol', 5, 0.5, 0.01)
+    >>> density(robSol).dict
+    {1: 0.204253668152708, 2: 0.490631107897393, 3: 0.165210624506162, 4: 0.0834387731899302, 5: 0.0505633404760675}
+    >>> density(robSol).set
+    {1, 2, 3, 4, 5}
+
+    >>> from sympy import Symbol
+    >>> k = Symbol('k', positive=True, integer=True)
+    >>> c = Symbol('c', positive=True)
+    >>> robSol = RobustSoliton('robSol', k, 0.5, c)
+    >>> density(robSol).dict
+    Density(RobustSolitonDistribution(k, 0.5, c))
+    >>> density(robSol).dict.subs(k, 10).subs(c, 0.03).doit()
+    {1: 0.116641095387194, 2: 0.467045731687165, 3: 0.159984123349381, 4: 0.0821431680681869, 5: 0.0505765646770100,
+    6: 0.0345781523420719, 7: 0.0253132820710503, 8: 0.0194459129233227, 9: 0.0154831166726115, 10: 0.0126733075238887}
+
+    >>> E(robSol.subs(k, 10).subs(c, 0.05))
+    2.91358846104106
+
+    >>> P(robSol.subs(k, 4).subs(c, 0.1) > 2)
+    0.243650614389834
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Soliton_distribution#Robust_distribution
+    .. [2] https://www.inference.org.uk/mackay/itprnn/ps/588.596.pdf
+    .. [3] https://pages.cs.wisc.edu/~suman/courses/740/papers/luby02lt.pdf
+
+    '''
+    return rv(name, RobustSolitonDistribution, k, delta, c)

venv/lib/python3.10/site-packages/sympy/stats/joint_rv.py

@@ -0,0 +1,426 @@
+"""
+Joint Random Variables Module
+
+See Also
+========
+sympy.stats.rv
+sympy.stats.frv
+sympy.stats.crv
+sympy.stats.drv
+"""
+from math import prod
+
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.core.sympify import sympify
+from sympy.sets.sets import ProductSet
+from sympy.tensor.indexed import Indexed
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum, summation
+from sympy.core.containers import Tuple
+from sympy.integrals.integrals import Integral, integrate
+from sympy.matrices import ImmutableMatrix, matrix2numpy, list2numpy
+from sympy.stats.crv import SingleContinuousDistribution, SingleContinuousPSpace
+from sympy.stats.drv import SingleDiscreteDistribution, SingleDiscretePSpace
+from sympy.stats.rv import (ProductPSpace, NamedArgsMixin, Distribution,
+                            ProductDomain, RandomSymbol, random_symbols,
+                            SingleDomain, _symbol_converter)
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import filldedent
+from sympy.external import import_module
+
+# __all__ = ['marginal_distribution']
+
+class JointPSpace(ProductPSpace):
+    """
+    Represents a joint probability space. Represented using symbols for
+    each component and a distribution.
+    """
+    def __new__(cls, sym, dist):
+        if isinstance(dist, SingleContinuousDistribution):
+            return SingleContinuousPSpace(sym, dist)
+        if isinstance(dist, SingleDiscreteDistribution):
+            return SingleDiscretePSpace(sym, dist)
+        sym = _symbol_converter(sym)
+        return Basic.__new__(cls, sym, dist)
+
+    @property
+    def set(self):
+        return self.domain.set
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def distribution(self):
+        return self.args[1]
+
+    @property
+    def value(self):
+        return JointRandomSymbol(self.symbol, self)
+
+    @property
+    def component_count(self):
+        _set = self.distribution.set
+        if isinstance(_set, ProductSet):
+            return S(len(_set.args))
+        elif isinstance(_set, Product):
+            return _set.limits[0][-1]
+        return S.One
+
+    @property
+    def pdf(self):
+        sym = [Indexed(self.symbol, i) for i in range(self.component_count)]
+        return self.distribution(*sym)
+
+    @property
+    def domain(self):
+        rvs = random_symbols(self.distribution)
+        if not rvs:
+            return SingleDomain(self.symbol, self.distribution.set)
+        return ProductDomain(*[rv.pspace.domain for rv in rvs])
+
+    def component_domain(self, index):
+        return self.set.args[index]
+
+    def marginal_distribution(self, *indices):
+        count = self.component_count
+        if count.atoms(Symbol):
+            raise ValueError("Marginal distributions cannot be computed "
+                                "for symbolic dimensions. It is a work under progress.")
+        orig = [Indexed(self.symbol, i) for i in range(count)]
+        all_syms = [Symbol(str(i)) for i in orig]
+        replace_dict = dict(zip(all_syms, orig))
+        sym = tuple(Symbol(str(Indexed(self.symbol, i))) for i in indices)
+        limits = [[i,] for i in all_syms if i not in sym]
+        index = 0
+        for i in range(count):
+            if i not in indices:
+                limits[index].append(self.distribution.set.args[i])
+                limits[index] = tuple(limits[index])
+                index += 1
+        if self.distribution.is_Continuous:
+            f = Lambda(sym, integrate(self.distribution(*all_syms), *limits))
+        elif self.distribution.is_Discrete:
+            f = Lambda(sym, summation(self.distribution(*all_syms), *limits))
+        return f.xreplace(replace_dict)
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        syms = tuple(self.value[i] for i in range(self.component_count))
+        rvs = rvs or syms
+        if not any(i in rvs for i in syms):
+            return expr
+        expr = expr*self.pdf
+        for rv in rvs:
+            if isinstance(rv, Indexed):
+                expr = expr.xreplace({rv: Indexed(str(rv.base), rv.args[1])})
+            elif isinstance(rv, RandomSymbol):
+                expr = expr.xreplace({rv: rv.symbol})
+        if self.value in random_symbols(expr):
+            raise NotImplementedError(filldedent('''
+            Expectations of expression with unindexed joint random symbols
+            cannot be calculated yet.'''))
+        limits = tuple((Indexed(str(rv.base),rv.args[1]),
+            self.distribution.set.args[rv.args[1]]) for rv in syms)
+        return Integral(expr, *limits)
+
+    def where(self, condition):
+        raise NotImplementedError()
+
+    def compute_density(self, expr):
+        raise NotImplementedError()
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+        return {RandomSymbol(self.symbol, self): self.distribution.sample(size,
+                    library=library, seed=seed)}
+
+    def probability(self, condition):
+        raise NotImplementedError()
+
+
+class SampleJointScipy:
+    """Returns the sample from scipy of the given distribution"""
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_scipy(dist, size, seed)
+
+    @classmethod
+    def _sample_scipy(cls, dist, size, seed):
+        """Sample from SciPy."""
+
+        import numpy
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        from scipy import stats as scipy_stats
+        scipy_rv_map = {
+            'MultivariateNormalDistribution': lambda dist, size: scipy_stats.multivariate_normal.rvs(
+                mean=matrix2numpy(dist.mu).flatten(),
+                cov=matrix2numpy(dist.sigma), size=size, random_state=rand_state),
+            'MultivariateBetaDistribution': lambda dist, size: scipy_stats.dirichlet.rvs(
+                alpha=list2numpy(dist.alpha, float).flatten(), size=size, random_state=rand_state),
+            'MultinomialDistribution': lambda dist, size: scipy_stats.multinomial.rvs(
+                n=int(dist.n), p=list2numpy(dist.p, float).flatten(), size=size, random_state=rand_state)
+        }
+
+        sample_shape = {
+            'MultivariateNormalDistribution': lambda dist: matrix2numpy(dist.mu).flatten().shape,
+            'MultivariateBetaDistribution': lambda dist: list2numpy(dist.alpha).flatten().shape,
+            'MultinomialDistribution': lambda dist: list2numpy(dist.p).flatten().shape
+        }
+
+        dist_list = scipy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        samples = scipy_rv_map[dist.__class__.__name__](dist, size)
+        return samples.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+class SampleJointNumpy:
+    """Returns the sample from numpy of the given distribution"""
+
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_numpy(dist, size, seed)
+
+    @classmethod
+    def _sample_numpy(cls, dist, size, seed):
+        """Sample from NumPy."""
+
+        import numpy
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        numpy_rv_map = {
+            'MultivariateNormalDistribution': lambda dist, size: rand_state.multivariate_normal(
+                mean=matrix2numpy(dist.mu, float).flatten(),
+                cov=matrix2numpy(dist.sigma, float), size=size),
+            'MultivariateBetaDistribution': lambda dist, size: rand_state.dirichlet(
+                alpha=list2numpy(dist.alpha, float).flatten(), size=size),
+            'MultinomialDistribution': lambda dist, size: rand_state.multinomial(
+                n=int(dist.n), pvals=list2numpy(dist.p, float).flatten(), size=size)
+        }
+
+        sample_shape = {
+            'MultivariateNormalDistribution': lambda dist: matrix2numpy(dist.mu).flatten().shape,
+            'MultivariateBetaDistribution': lambda dist: list2numpy(dist.alpha).flatten().shape,
+            'MultinomialDistribution': lambda dist: list2numpy(dist.p).flatten().shape
+        }
+
+        dist_list = numpy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        samples = numpy_rv_map[dist.__class__.__name__](dist, prod(size))
+        return samples.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+class SampleJointPymc:
+    """Returns the sample from pymc of the given distribution"""
+
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_pymc(dist, size, seed)
+
+    @classmethod
+    def _sample_pymc(cls, dist, size, seed):
+        """Sample from PyMC."""
+
+        try:
+            import pymc
+        except ImportError:
+            import pymc3 as pymc
+        pymc_rv_map = {
+            'MultivariateNormalDistribution': lambda dist:
+                pymc.MvNormal('X', mu=matrix2numpy(dist.mu, float).flatten(),
+                cov=matrix2numpy(dist.sigma, float), shape=(1, dist.mu.shape[0])),
+            'MultivariateBetaDistribution': lambda dist:
+                pymc.Dirichlet('X', a=list2numpy(dist.alpha, float).flatten()),
+            'MultinomialDistribution': lambda dist:
+                pymc.Multinomial('X', n=int(dist.n),
+                p=list2numpy(dist.p, float).flatten(), shape=(1, len(dist.p)))
+        }
+
+        sample_shape = {
+            'MultivariateNormalDistribution': lambda dist: matrix2numpy(dist.mu).flatten().shape,
+            'MultivariateBetaDistribution': lambda dist: list2numpy(dist.alpha).flatten().shape,
+            'MultinomialDistribution': lambda dist: list2numpy(dist.p).flatten().shape
+        }
+
+        dist_list = pymc_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        import logging
+        logging.getLogger("pymc3").setLevel(logging.ERROR)
+        with pymc.Model():
+            pymc_rv_map[dist.__class__.__name__](dist)
+            samples = pymc.sample(draws=prod(size), chains=1, progressbar=False, random_seed=seed, return_inferencedata=False, compute_convergence_checks=False)[:]['X']
+        return samples.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+
+_get_sample_class_jrv = {
+    'scipy': SampleJointScipy,
+    'pymc3': SampleJointPymc,
+    'pymc': SampleJointPymc,
+    'numpy': SampleJointNumpy
+}
+
+class JointDistribution(Distribution, NamedArgsMixin):
+    """
+    Represented by the random variables part of the joint distribution.
+    Contains methods for PDF, CDF, sampling, marginal densities, etc.
+    """
+
+    _argnames = ('pdf', )
+
+    def __new__(cls, *args):
+        args = list(map(sympify, args))
+        for i in range(len(args)):
+            if isinstance(args[i], list):
+                args[i] = ImmutableMatrix(args[i])
+        return Basic.__new__(cls, *args)
+
+    @property
+    def domain(self):
+        return ProductDomain(self.symbols)
+
+    @property
+    def pdf(self):
+        return self.density.args[1]
+
+    def cdf(self, other):
+        if not isinstance(other, dict):
+            raise ValueError("%s should be of type dict, got %s"%(other, type(other)))
+        rvs = other.keys()
+        _set = self.domain.set.sets
+        expr = self.pdf(tuple(i.args[0] for i in self.symbols))
+        for i in range(len(other)):
+            if rvs[i].is_Continuous:
+                density = Integral(expr, (rvs[i], _set[i].inf,
+                    other[rvs[i]]))
+            elif rvs[i].is_Discrete:
+                density = Sum(expr, (rvs[i], _set[i].inf,
+                    other[rvs[i]]))
+        return density
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """ A random realization from the distribution """
+
+        libraries = ('scipy', 'numpy', 'pymc3', 'pymc')
+        if library not in libraries:
+            raise NotImplementedError("Sampling from %s is not supported yet."
+                                        % str(library))
+        if not import_module(library):
+            raise ValueError("Failed to import %s" % library)
+
+        samps = _get_sample_class_jrv[library](self, size, seed=seed)
+
+        if samps is not None:
+            return samps
+        raise NotImplementedError(
+                "Sampling for %s is not currently implemented from %s"
+                % (self.__class__.__name__, library)
+                )
+
+    def __call__(self, *args):
+        return self.pdf(*args)
+
+class JointRandomSymbol(RandomSymbol):
+    """
+    Representation of random symbols with joint probability distributions
+    to allow indexing."
+    """
+    def __getitem__(self, key):
+        if isinstance(self.pspace, JointPSpace):
+            if (self.pspace.component_count <= key) == True:
+                raise ValueError("Index keys for %s can only up to %s." %
+                    (self.name, self.pspace.component_count - 1))
+            return Indexed(self, key)
+
+
+
+class MarginalDistribution(Distribution):
+    """
+    Represents the marginal distribution of a joint probability space.
+
+    Initialised using a probability distribution and random variables(or
+    their indexed components) which should be a part of the resultant
+    distribution.
+    """
+
+    def __new__(cls, dist, *rvs):
+        if len(rvs) == 1 and iterable(rvs[0]):
+            rvs = tuple(rvs[0])
+        if not all(isinstance(rv, (Indexed, RandomSymbol)) for rv in rvs):
+            raise ValueError(filldedent('''Marginal distribution can be
+             intitialised only in terms of random variables or indexed random
+             variables'''))
+        rvs = Tuple.fromiter(rv for rv in rvs)
+        if not isinstance(dist, JointDistribution) and len(random_symbols(dist)) == 0:
+            return dist
+        return Basic.__new__(cls, dist, rvs)
+
+    def check(self):
+        pass
+
+    @property
+    def set(self):
+        rvs = [i for i in self.args[1] if isinstance(i, RandomSymbol)]
+        return ProductSet(*[rv.pspace.set for rv in rvs])
+
+    @property
+    def symbols(self):
+        rvs = self.args[1]
+        return {rv.pspace.symbol for rv in rvs}
+
+    def pdf(self, *x):
+        expr, rvs = self.args[0], self.args[1]
+        marginalise_out = [i for i in random_symbols(expr) if i not in rvs]
+        if isinstance(expr, JointDistribution):
+            count = len(expr.domain.args)
+            x = Dummy('x', real=True)
+            syms = tuple(Indexed(x, i) for i in count)
+            expr = expr.pdf(syms)
+        else:
+            syms = tuple(rv.pspace.symbol if isinstance(rv, RandomSymbol) else rv.args[0] for rv in rvs)
+        return Lambda(syms, self.compute_pdf(expr, marginalise_out))(*x)
+
+    def compute_pdf(self, expr, rvs):
+        for rv in rvs:
+            lpdf = 1
+            if isinstance(rv, RandomSymbol):
+                lpdf = rv.pspace.pdf
+            expr = self.marginalise_out(expr*lpdf, rv)
+        return expr
+
+    def marginalise_out(self, expr, rv):
+        from sympy.concrete.summations import Sum
+        if isinstance(rv, RandomSymbol):
+            dom = rv.pspace.set
+        elif isinstance(rv, Indexed):
+            dom = rv.base.component_domain(
+                rv.pspace.component_domain(rv.args[1]))
+        expr = expr.xreplace({rv: rv.pspace.symbol})
+        if rv.pspace.is_Continuous:
+            #TODO: Modify to support integration
+            #for all kinds of sets.
+            expr = Integral(expr, (rv.pspace.symbol, dom))
+        elif rv.pspace.is_Discrete:
+            #incorporate this into `Sum`/`summation`
+            if dom in (S.Integers, S.Naturals, S.Naturals0):
+                dom = (dom.inf, dom.sup)
+            expr = Sum(expr, (rv.pspace.symbol, dom))
+        return expr
+
+    def __call__(self, *args):
+        return self.pdf(*args)

venv/lib/python3.10/site-packages/sympy/stats/joint_rv_types.py

@@ -0,0 +1,946 @@
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.function import Lambda
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Integer, Rational, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (rf, factorial)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besselk
+from sympy.functions.special.gamma_functions import gamma
+from sympy.matrices.dense import (Matrix, ones)
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (Intersection, Interval)
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.matrices import ImmutableMatrix, MatrixSymbol
+from sympy.matrices.expressions.determinant import det
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.stats.joint_rv import JointDistribution, JointPSpace, MarginalDistribution
+from sympy.stats.rv import _value_check, random_symbols
+
+__all__ = ['JointRV',
+'MultivariateNormal',
+'MultivariateLaplace',
+'Dirichlet',
+'GeneralizedMultivariateLogGamma',
+'GeneralizedMultivariateLogGammaOmega',
+'Multinomial',
+'MultivariateBeta',
+'MultivariateEwens',
+'MultivariateT',
+'NegativeMultinomial',
+'NormalGamma'
+]
+
+def multivariate_rv(cls, sym, *args):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    args = dist.args
+    dist.check(*args)
+    return JointPSpace(sym, dist).value
+
+
+def marginal_distribution(rv, *indices):
+    """
+    Marginal distribution function of a joint random variable.
+
+    Parameters
+    ==========
+
+    rv : A random variable with a joint probability distribution.
+    indices : Component indices or the indexed random symbol
+        for which the joint distribution is to be calculated
+
+    Returns
+    =======
+
+    A Lambda expression in `sym`.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import MultivariateNormal, marginal_distribution
+    >>> m = MultivariateNormal('X', [1, 2], [[2, 1], [1, 2]])
+    >>> marginal_distribution(m, m[0])(1)
+    1/(2*sqrt(pi))
+
+    """
+    indices = list(indices)
+    for i in range(len(indices)):
+        if isinstance(indices[i], Indexed):
+            indices[i] = indices[i].args[1]
+    prob_space = rv.pspace
+    if not indices:
+        raise ValueError(
+            "At least one component for marginal density is needed.")
+    if hasattr(prob_space.distribution, '_marginal_distribution'):
+        return prob_space.distribution._marginal_distribution(indices, rv.symbol)
+    return prob_space.marginal_distribution(*indices)
+
+
+class JointDistributionHandmade(JointDistribution):
+
+    _argnames = ('pdf',)
+    is_Continuous = True
+
+    @property
+    def set(self):
+        return self.args[1]
+
+
+def JointRV(symbol, pdf, _set=None):
+    """
+    Create a Joint Random Variable where each of its component is continuous,
+    given the following:
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        Represents name of the random variable.
+    pdf : A PDF in terms of indexed symbols of the symbol given
+        as the first argument
+
+    NOTE
+    ====
+
+    As of now, the set for each component for a ``JointRV`` is
+    equal to the set of all integers, which cannot be changed.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, pi, Indexed, S
+    >>> from sympy.stats import density, JointRV
+    >>> x1, x2 = (Indexed('x', i) for i in (1, 2))
+    >>> pdf = exp(-x1**2/2 + x1 - x2**2/2 - S(1)/2)/(2*pi)
+    >>> N1 = JointRV('x', pdf) #Multivariate Normal distribution
+    >>> density(N1)(1, 2)
+    exp(-2)/(2*pi)
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    #TODO: Add support for sets provided by the user
+    symbol = sympify(symbol)
+    syms = [i for i in pdf.free_symbols if isinstance(i, Indexed)
+        and i.base == IndexedBase(symbol)]
+    syms = tuple(sorted(syms, key = lambda index: index.args[1]))
+    _set = S.Reals**len(syms)
+    pdf = Lambda(syms, pdf)
+    dist = JointDistributionHandmade(pdf, _set)
+    jrv = JointPSpace(symbol, dist).value
+    rvs = random_symbols(pdf)
+    if len(rvs) != 0:
+        dist = MarginalDistribution(dist, (jrv,))
+        return JointPSpace(symbol, dist).value
+    return jrv
+
+#-------------------------------------------------------------------------------
+# Multivariate Normal distribution ---------------------------------------------
+
+class MultivariateNormalDistribution(JointDistribution):
+    _argnames = ('mu', 'sigma')
+
+    is_Continuous=True
+
+    @property
+    def set(self):
+        k = self.mu.shape[0]
+        return S.Reals**k
+
+    @staticmethod
+    def check(mu, sigma):
+        _value_check(mu.shape[0] == sigma.shape[0],
+            "Size of the mean vector and covariance matrix are incorrect.")
+        #check if covariance matrix is positive semi definite or not.
+        if not isinstance(sigma, MatrixSymbol):
+            _value_check(sigma.is_positive_semidefinite,
+            "The covariance matrix must be positive semi definite. ")
+
+    def pdf(self, *args):
+        mu, sigma = self.mu, self.sigma
+        k = mu.shape[0]
+        if len(args) == 1 and args[0].is_Matrix:
+            args = args[0]
+        else:
+            args = ImmutableMatrix(args)
+        x = args - mu
+        density = S.One/sqrt((2*pi)**(k)*det(sigma))*exp(
+            Rational(-1, 2)*x.transpose()*(sigma.inv()*x))
+        return MatrixElement(density, 0, 0)
+
+    def _marginal_distribution(self, indices, sym):
+        sym = ImmutableMatrix([Indexed(sym, i) for i in indices])
+        _mu, _sigma = self.mu, self.sigma
+        k = self.mu.shape[0]
+        for i in range(k):
+            if i not in indices:
+                _mu = _mu.row_del(i)
+                _sigma = _sigma.col_del(i)
+                _sigma = _sigma.row_del(i)
+        return Lambda(tuple(sym), S.One/sqrt((2*pi)**(len(_mu))*det(_sigma))*exp(
+            Rational(-1, 2)*(_mu - sym).transpose()*(_sigma.inv()*\
+                (_mu - sym)))[0])
+
+def MultivariateNormal(name, mu, sigma):
+    r"""
+    Creates a continuous random variable with Multivariate Normal
+    Distribution.
+
+    The density of the multivariate normal distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    mu : List representing the mean or the mean vector
+    sigma : Positive semidefinite square matrix
+        Represents covariance Matrix.
+        If `\sigma` is noninvertible then only sampling is supported currently
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import MultivariateNormal, density, marginal_distribution
+    >>> from sympy import symbols, MatrixSymbol
+    >>> X = MultivariateNormal('X', [3, 4], [[2, 1], [1, 2]])
+    >>> y, z = symbols('y z')
+    >>> density(X)(y, z)
+    sqrt(3)*exp(-y**2/3 + y*z/3 + 2*y/3 - z**2/3 + 5*z/3 - 13/3)/(6*pi)
+    >>> density(X)(1, 2)
+    sqrt(3)*exp(-4/3)/(6*pi)
+    >>> marginal_distribution(X, X[1])(y)
+    exp(-(y - 4)**2/4)/(2*sqrt(pi))
+    >>> marginal_distribution(X, X[0])(y)
+    exp(-(y - 3)**2/4)/(2*sqrt(pi))
+
+    The example below shows that it is also possible to use
+    symbolic parameters to define the MultivariateNormal class.
+
+    >>> n = symbols('n', integer=True, positive=True)
+    >>> Sg = MatrixSymbol('Sg', n, n)
+    >>> mu = MatrixSymbol('mu', n, 1)
+    >>> obs = MatrixSymbol('obs', n, 1)
+    >>> X = MultivariateNormal('X', mu, Sg)
+
+    The density of a multivariate normal can be
+    calculated using a matrix argument, as shown below.
+
+    >>> density(X)(obs)
+    (exp(((1/2)*mu.T - (1/2)*obs.T)*Sg**(-1)*(-mu + obs))/sqrt((2*pi)**n*Determinant(Sg)))[0, 0]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multivariate_normal_distribution
+
+    """
+    return multivariate_rv(MultivariateNormalDistribution, name, mu, sigma)
+
+#-------------------------------------------------------------------------------
+# Multivariate Laplace distribution --------------------------------------------
+
+class MultivariateLaplaceDistribution(JointDistribution):
+    _argnames = ('mu', 'sigma')
+    is_Continuous=True
+
+    @property
+    def set(self):
+        k = self.mu.shape[0]
+        return S.Reals**k
+
+    @staticmethod
+    def check(mu, sigma):
+        _value_check(mu.shape[0] == sigma.shape[0],
+                     "Size of the mean vector and covariance matrix are incorrect.")
+        # check if covariance matrix is positive definite or not.
+        if not isinstance(sigma, MatrixSymbol):
+            _value_check(sigma.is_positive_definite,
+                         "The covariance matrix must be positive definite. ")
+
+    def pdf(self, *args):
+        mu, sigma = self.mu, self.sigma
+        mu_T = mu.transpose()
+        k = S(mu.shape[0])
+        sigma_inv = sigma.inv()
+        args = ImmutableMatrix(args)
+        args_T = args.transpose()
+        x = (mu_T*sigma_inv*mu)[0]
+        y = (args_T*sigma_inv*args)[0]
+        v = 1 - k/2
+        return (2 * (y/(2 + x))**(v/2) * besselk(v, sqrt((2 + x)*y)) *
+                exp((args_T * sigma_inv * mu)[0]) /
+                ((2 * pi)**(k/2) * sqrt(det(sigma))))
+
+
+def MultivariateLaplace(name, mu, sigma):
+    """
+    Creates a continuous random variable with Multivariate Laplace
+    Distribution.
+
+    The density of the multivariate Laplace distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    mu : List representing the mean or the mean vector
+    sigma : Positive definite square matrix
+        Represents covariance Matrix
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import MultivariateLaplace, density
+    >>> from sympy import symbols
+    >>> y, z = symbols('y z')
+    >>> X = MultivariateLaplace('X', [2, 4], [[3, 1], [1, 3]])
+    >>> density(X)(y, z)
+    sqrt(2)*exp(y/4 + 5*z/4)*besselk(0, sqrt(15*y*(3*y/8 - z/8)/2 + 15*z*(-y/8 + 3*z/8)/2))/(4*pi)
+    >>> density(X)(1, 2)
+    sqrt(2)*exp(11/4)*besselk(0, sqrt(165)/4)/(4*pi)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multivariate_Laplace_distribution
+
+    """
+    return multivariate_rv(MultivariateLaplaceDistribution, name, mu, sigma)
+
+#-------------------------------------------------------------------------------
+# Multivariate StudentT distribution -------------------------------------------
+
+class MultivariateTDistribution(JointDistribution):
+    _argnames = ('mu', 'shape_mat', 'dof')
+    is_Continuous=True
+
+    @property
+    def set(self):
+        k = self.mu.shape[0]
+        return S.Reals**k
+
+    @staticmethod
+    def check(mu, sigma, v):
+        _value_check(mu.shape[0] == sigma.shape[0],
+                     "Size of the location vector and shape matrix are incorrect.")
+        # check if covariance matrix is positive definite or not.
+        if not isinstance(sigma, MatrixSymbol):
+            _value_check(sigma.is_positive_definite,
+                         "The shape matrix must be positive definite. ")
+
+    def pdf(self, *args):
+        mu, sigma = self.mu, self.shape_mat
+        v = S(self.dof)
+        k = S(mu.shape[0])
+        sigma_inv = sigma.inv()
+        args = ImmutableMatrix(args)
+        x = args - mu
+        return gamma((k + v)/2)/(gamma(v/2)*(v*pi)**(k/2)*sqrt(det(sigma)))\
+        *(1 + 1/v*(x.transpose()*sigma_inv*x)[0])**((-v - k)/2)
+
+def MultivariateT(syms, mu, sigma, v):
+    """
+    Creates a joint random variable with multivariate T-distribution.
+
+    Parameters
+    ==========
+
+    syms : A symbol/str
+        For identifying the random variable.
+    mu : A list/matrix
+        Representing the location vector
+    sigma : The shape matrix for the distribution
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, MultivariateT
+    >>> from sympy import Symbol
+
+    >>> x = Symbol("x")
+    >>> X = MultivariateT("x", [1, 1], [[1, 0], [0, 1]], 2)
+
+    >>> density(X)(1, 2)
+    2/(9*pi)
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    return multivariate_rv(MultivariateTDistribution, syms, mu, sigma, v)
+
+
+#-------------------------------------------------------------------------------
+# Multivariate Normal Gamma distribution ---------------------------------------
+
+class NormalGammaDistribution(JointDistribution):
+
+    _argnames = ('mu', 'lamda', 'alpha', 'beta')
+    is_Continuous=True
+
+    @staticmethod
+    def check(mu, lamda, alpha, beta):
+        _value_check(mu.is_real, "Location must be real.")
+        _value_check(lamda > 0, "Lambda must be positive")
+        _value_check(alpha > 0, "alpha must be positive")
+        _value_check(beta > 0, "beta must be positive")
+
+    @property
+    def set(self):
+        return S.Reals*Interval(0, S.Infinity)
+
+    def pdf(self, x, tau):
+        beta, alpha, lamda = self.beta, self.alpha, self.lamda
+        mu = self.mu
+
+        return beta**alpha*sqrt(lamda)/(gamma(alpha)*sqrt(2*pi))*\
+        tau**(alpha - S.Half)*exp(-1*beta*tau)*\
+        exp(-1*(lamda*tau*(x - mu)**2)/S(2))
+
+    def _marginal_distribution(self, indices, *sym):
+        if len(indices) == 2:
+            return self.pdf(*sym)
+        if indices[0] == 0:
+            #For marginal over `x`, return non-standardized Student-T's
+            #distribution
+            x = sym[0]
+            v, mu, sigma = self.alpha - S.Half, self.mu, \
+                S(self.beta)/(self.lamda * self.alpha)
+            return Lambda(sym, gamma((v + 1)/2)/(gamma(v/2)*sqrt(pi*v)*sigma)*\
+                (1 + 1/v*((x - mu)/sigma)**2)**((-v -1)/2))
+        #For marginal over `tau`, return Gamma distribution as per construction
+        from sympy.stats.crv_types import GammaDistribution
+        return Lambda(sym, GammaDistribution(self.alpha, self.beta)(sym[0]))
+
+def NormalGamma(sym, mu, lamda, alpha, beta):
+    """
+    Creates a bivariate joint random variable with multivariate Normal gamma
+    distribution.
+
+    Parameters
+    ==========
+
+    sym : A symbol/str
+        For identifying the random variable.
+    mu : A real number
+        The mean of the normal distribution
+    lamda : A positive integer
+        Parameter of joint distribution
+    alpha : A positive integer
+        Parameter of joint distribution
+    beta : A positive integer
+        Parameter of joint distribution
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, NormalGamma
+    >>> from sympy import symbols
+
+    >>> X = NormalGamma('x', 0, 1, 2, 3)
+    >>> y, z = symbols('y z')
+
+    >>> density(X)(y, z)
+    9*sqrt(2)*z**(3/2)*exp(-3*z)*exp(-y**2*z/2)/(2*sqrt(pi))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Normal-gamma_distribution
+
+    """
+    return multivariate_rv(NormalGammaDistribution, sym, mu, lamda, alpha, beta)
+
+#-------------------------------------------------------------------------------
+# Multivariate Beta/Dirichlet distribution -------------------------------------
+
+class MultivariateBetaDistribution(JointDistribution):
+
+    _argnames = ('alpha',)
+    is_Continuous = True
+
+    @staticmethod
+    def check(alpha):
+        _value_check(len(alpha) >= 2, "At least two categories should be passed.")
+        for a_k in alpha:
+            _value_check((a_k > 0) != False, "Each concentration parameter"
+                                            " should be positive.")
+
+    @property
+    def set(self):
+        k = len(self.alpha)
+        return Interval(0, 1)**k
+
+    def pdf(self, *syms):
+        alpha = self.alpha
+        B = Mul.fromiter(map(gamma, alpha))/gamma(Add(*alpha))
+        return Mul.fromiter(sym**(a_k - 1) for a_k, sym in zip(alpha, syms))/B
+
+def MultivariateBeta(syms, *alpha):
+    """
+    Creates a continuous random variable with Dirichlet/Multivariate Beta
+    Distribution.
+
+    The density of the Dirichlet distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    alpha : Positive real numbers
+        Signifies concentration numbers.
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, MultivariateBeta, marginal_distribution
+    >>> from sympy import Symbol
+    >>> a1 = Symbol('a1', positive=True)
+    >>> a2 = Symbol('a2', positive=True)
+    >>> B = MultivariateBeta('B', [a1, a2])
+    >>> C = MultivariateBeta('C', a1, a2)
+    >>> x = Symbol('x')
+    >>> y = Symbol('y')
+    >>> density(B)(x, y)
+    x**(a1 - 1)*y**(a2 - 1)*gamma(a1 + a2)/(gamma(a1)*gamma(a2))
+    >>> marginal_distribution(C, C[0])(x)
+    x**(a1 - 1)*gamma(a1 + a2)/(a2*gamma(a1)*gamma(a2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Dirichlet_distribution
+    .. [2] https://mathworld.wolfram.com/DirichletDistribution.html
+
+    """
+    if not isinstance(alpha[0], list):
+        alpha = (list(alpha),)
+    return multivariate_rv(MultivariateBetaDistribution, syms, alpha[0])
+
+Dirichlet = MultivariateBeta
+
+#-------------------------------------------------------------------------------
+# Multivariate Ewens distribution ----------------------------------------------
+
+class MultivariateEwensDistribution(JointDistribution):
+
+    _argnames = ('n', 'theta')
+    is_Discrete = True
+    is_Continuous = False
+
+    @staticmethod
+    def check(n, theta):
+        _value_check((n > 0),
+                        "sample size should be positive integer.")
+        _value_check(theta.is_positive, "mutation rate should be positive.")
+
+    @property
+    def set(self):
+        if not isinstance(self.n, Integer):
+            i = Symbol('i', integer=True, positive=True)
+            return Product(Intersection(S.Naturals0, Interval(0, self.n//i)),
+                                    (i, 1, self.n))
+        prod_set = Range(0, self.n + 1)
+        for i in range(2, self.n + 1):
+            prod_set *= Range(0, self.n//i + 1)
+        return prod_set.flatten()
+
+    def pdf(self, *syms):
+        n, theta = self.n, self.theta
+        condi = isinstance(self.n, Integer)
+        if not (isinstance(syms[0], IndexedBase) or condi):
+            raise ValueError("Please use IndexedBase object for syms as "
+                                "the dimension is symbolic")
+        term_1 = factorial(n)/rf(theta, n)
+        if condi:
+            term_2 = Mul.fromiter(theta**syms[j]/((j+1)**syms[j]*factorial(syms[j]))
+                                    for j in range(n))
+            cond = Eq(sum([(k + 1)*syms[k] for k in range(n)]), n)
+            return Piecewise((term_1 * term_2, cond), (0, True))
+        syms = syms[0]
+        j, k = symbols('j, k', positive=True, integer=True)
+        term_2 = Product(theta**syms[j]/((j+1)**syms[j]*factorial(syms[j])),
+                            (j, 0, n - 1))
+        cond = Eq(Sum((k + 1)*syms[k], (k, 0, n - 1)), n)
+        return Piecewise((term_1 * term_2, cond), (0, True))
+
+
+def MultivariateEwens(syms, n, theta):
+    """
+    Creates a discrete random variable with Multivariate Ewens
+    Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    n : Positive integer
+        Size of the sample or the integer whose partitions are considered
+    theta : Positive real number
+        Denotes Mutation rate
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, marginal_distribution, MultivariateEwens
+    >>> from sympy import Symbol
+    >>> a1 = Symbol('a1', positive=True)
+    >>> a2 = Symbol('a2', positive=True)
+    >>> ed = MultivariateEwens('E', 2, 1)
+    >>> density(ed)(a1, a2)
+    Piecewise((1/(2**a2*factorial(a1)*factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True))
+    >>> marginal_distribution(ed, ed[0])(a1)
+    Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Ewens%27s_sampling_formula
+    .. [2] https://www.researchgate.net/publication/280311472_The_Ubiquitous_Ewens_Sampling_Formula
+
+    """
+    return multivariate_rv(MultivariateEwensDistribution, syms, n, theta)
+
+#-------------------------------------------------------------------------------
+# Generalized Multivariate Log Gamma distribution ------------------------------
+
+class GeneralizedMultivariateLogGammaDistribution(JointDistribution):
+
+    _argnames = ('delta', 'v', 'lamda', 'mu')
+    is_Continuous=True
+
+    def check(self, delta, v, l, mu):
+        _value_check((delta >= 0, delta <= 1), "delta must be in range [0, 1].")
+        _value_check((v > 0), "v must be positive")
+        for lk in l:
+            _value_check((lk > 0), "lamda must be a positive vector.")
+        for muk in mu:
+            _value_check((muk > 0), "mu must be a positive vector.")
+        _value_check(len(l) > 1,"the distribution should have at least"
+                                " two random variables.")
+
+    @property
+    def set(self):
+        return S.Reals**len(self.lamda)
+
+    def pdf(self, *y):
+        d, v, l, mu = self.delta, self.v, self.lamda, self.mu
+        n = Symbol('n', negative=False, integer=True)
+        k = len(l)
+        sterm1 = Pow((1 - d), n)/\
+                ((gamma(v + n)**(k - 1))*gamma(v)*gamma(n + 1))
+        sterm2 = Mul.fromiter(mui*li**(-v - n) for mui, li in zip(mu, l))
+        term1 = sterm1 * sterm2
+        sterm3 = (v + n) * sum([mui * yi for mui, yi in zip(mu, y)])
+        sterm4 = sum([exp(mui * yi)/li for (mui, yi, li) in zip(mu, y, l)])
+        term2 = exp(sterm3 - sterm4)
+        return Pow(d, v) * Sum(term1 * term2, (n, 0, S.Infinity))
+
+def GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu):
+    """
+    Creates a joint random variable with generalized multivariate log gamma
+    distribution.
+
+    The joint pdf can be found at [1].
+
+    Parameters
+    ==========
+
+    syms : list/tuple/set of symbols for identifying each component
+    delta : A constant in range $[0, 1]$
+    v : Positive real number
+    lamda : List of positive real numbers
+    mu : List of positive real numbers
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma
+    >>> from sympy import symbols, S
+    >>> v = 1
+    >>> l, mu = [1, 1, 1], [1, 1, 1]
+    >>> d = S.Half
+    >>> y = symbols('y_1:4', positive=True)
+    >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu)
+    >>> density(Gd)(y[0], y[1], y[2])
+    Sum(exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) -
+    exp(y_3))/(2**n*gamma(n + 1)**3), (n, 0, oo))/2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution
+    .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis
+
+    Note
+    ====
+
+    If the GeneralizedMultivariateLogGamma is too long to type use,
+
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG
+    >>> Gd = GMVLG('G', d, v, l, mu)
+
+    If you want to pass the matrix omega instead of the constant delta, then use
+    ``GeneralizedMultivariateLogGammaOmega``.
+
+    """
+    return multivariate_rv(GeneralizedMultivariateLogGammaDistribution,
+                            syms, delta, v, lamda, mu)
+
+def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu):
+    """
+    Extends GeneralizedMultivariateLogGamma.
+
+    Parameters
+    ==========
+
+    syms : list/tuple/set of symbols
+        For identifying each component
+    omega : A square matrix
+           Every element of square matrix must be absolute value of
+           square root of correlation coefficient
+    v : Positive real number
+    lamda : List of positive real numbers
+    mu : List of positive real numbers
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega
+    >>> from sympy import Matrix, symbols, S
+    >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]])
+    >>> v = 1
+    >>> l, mu = [1, 1, 1], [1, 1, 1]
+    >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu)
+    >>> y = symbols('y_1:4', positive=True)
+    >>> density(G)(y[0], y[1], y[2])
+    sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) -
+    exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution
+    .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis
+
+    Notes
+    =====
+
+    If the GeneralizedMultivariateLogGammaOmega is too long to type use,
+
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO
+    >>> G = GMVLGO('G', omega, v, l, mu)
+
+    """
+    _value_check((omega.is_square, isinstance(omega, Matrix)), "omega must be a"
+                                                            " square matrix")
+    for val in omega.values():
+        _value_check((val >= 0, val <= 1),
+            "all values in matrix must be between 0 and 1(both inclusive).")
+    _value_check(omega.diagonal().equals(ones(1, omega.shape[0])),
+                    "all the elements of diagonal should be 1.")
+    _value_check((omega.shape[0] == len(lamda), len(lamda) == len(mu)),
+                    "lamda, mu should be of same length and omega should "
+                    " be of shape (length of lamda, length of mu)")
+    _value_check(len(lamda) > 1,"the distribution should have at least"
+                            " two random variables.")
+    delta = Pow(Rational(omega.det()), Rational(1, len(lamda) - 1))
+    return GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu)
+
+
+#-------------------------------------------------------------------------------
+# Multinomial distribution -----------------------------------------------------
+
+class MultinomialDistribution(JointDistribution):
+
+    _argnames = ('n', 'p')
+    is_Continuous=False
+    is_Discrete = True
+
+    @staticmethod
+    def check(n, p):
+        _value_check(n > 0,
+                        "number of trials must be a positive integer")
+        for p_k in p:
+            _value_check((p_k >= 0, p_k <= 1),
+                        "probability must be in range [0, 1]")
+        _value_check(Eq(sum(p), 1),
+                        "probabilities must sum to 1")
+
+    @property
+    def set(self):
+        return Intersection(S.Naturals0, Interval(0, self.n))**len(self.p)
+
+    def pdf(self, *x):
+        n, p = self.n, self.p
+        term_1 = factorial(n)/Mul.fromiter(factorial(x_k) for x_k in x)
+        term_2 = Mul.fromiter(p_k**x_k for p_k, x_k in zip(p, x))
+        return Piecewise((term_1 * term_2, Eq(sum(x), n)), (0, True))
+
+def Multinomial(syms, n, *p):
+    """
+    Creates a discrete random variable with Multinomial Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    n : Positive integer
+        Represents number of trials
+    p : List of event probabilities
+        Must be in the range of $[0, 1]$.
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, Multinomial, marginal_distribution
+    >>> from sympy import symbols
+    >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True)
+    >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True)
+    >>> M = Multinomial('M', 3, p1, p2, p3)
+    >>> density(M)(x1, x2, x3)
+    Piecewise((6*p1**x1*p2**x2*p3**x3/(factorial(x1)*factorial(x2)*factorial(x3)),
+    Eq(x1 + x2 + x3, 3)), (0, True))
+    >>> marginal_distribution(M, M[0])(x1).subs(x1, 1)
+    3*p1*p2**2 + 6*p1*p2*p3 + 3*p1*p3**2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multinomial_distribution
+    .. [2] https://mathworld.wolfram.com/MultinomialDistribution.html
+
+    """
+    if not isinstance(p[0], list):
+        p = (list(p), )
+    return multivariate_rv(MultinomialDistribution, syms, n, p[0])
+
+#-------------------------------------------------------------------------------
+# Negative Multinomial Distribution --------------------------------------------
+
+class NegativeMultinomialDistribution(JointDistribution):
+
+    _argnames = ('k0', 'p')
+    is_Continuous=False
+    is_Discrete = True
+
+    @staticmethod
+    def check(k0, p):
+        _value_check(k0 > 0,
+                        "number of failures must be a positive integer")
+        for p_k in p:
+            _value_check((p_k >= 0, p_k <= 1),
+                        "probability must be in range [0, 1].")
+        _value_check(sum(p) <= 1,
+                        "success probabilities must not be greater than 1.")
+
+    @property
+    def set(self):
+        return Range(0, S.Infinity)**len(self.p)
+
+    def pdf(self, *k):
+        k0, p = self.k0, self.p
+        term_1 = (gamma(k0 + sum(k))*(1 - sum(p))**k0)/gamma(k0)
+        term_2 = Mul.fromiter(pi**ki/factorial(ki) for pi, ki in zip(p, k))
+        return term_1 * term_2
+
+def NegativeMultinomial(syms, k0, *p):
+    """
+    Creates a discrete random variable with Negative Multinomial Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    k0 : positive integer
+        Represents number of failures before the experiment is stopped
+    p : List of event probabilities
+        Must be in the range of $[0, 1]$
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, NegativeMultinomial, marginal_distribution
+    >>> from sympy import symbols
+    >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True)
+    >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True)
+    >>> N = NegativeMultinomial('M', 3, p1, p2, p3)
+    >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1)
+    >>> density(N)(x1, x2, x3)
+    p1**x1*p2**x2*p3**x3*(-p1 - p2 - p3 + 1)**3*gamma(x1 + x2 +
+    x3 + 3)/(2*factorial(x1)*factorial(x2)*factorial(x3))
+    >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2)
+    0.25
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Negative_multinomial_distribution
+    .. [2] https://mathworld.wolfram.com/NegativeBinomialDistribution.html
+
+    """
+    if not isinstance(p[0], list):
+        p = (list(p), )
+    return multivariate_rv(NegativeMultinomialDistribution, syms, k0, p[0])

venv/lib/python3.10/site-packages/sympy/stats/matrix_distributions.py

@@ -0,0 +1,610 @@
+from math import prod
+
+from sympy.core.basic import Basic
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.special.gamma_functions import multigamma
+from sympy.core.sympify import sympify, _sympify
+from sympy.matrices import (ImmutableMatrix, Inverse, Trace, Determinant,
+                            MatrixSymbol, MatrixBase, Transpose, MatrixSet,
+                            matrix2numpy)
+from sympy.stats.rv import (_value_check, RandomMatrixSymbol, NamedArgsMixin, PSpace,
+                            _symbol_converter, MatrixDomain, Distribution)
+from sympy.external import import_module
+
+
+################################################################################
+#------------------------Matrix Probability Space------------------------------#
+################################################################################
+class MatrixPSpace(PSpace):
+    """
+    Represents probability space for
+    Matrix Distributions.
+    """
+    def __new__(cls, sym, distribution, dim_n, dim_m):
+        sym = _symbol_converter(sym)
+        dim_n, dim_m = _sympify(dim_n), _sympify(dim_m)
+        if not (dim_n.is_integer and dim_m.is_integer):
+            raise ValueError("Dimensions should be integers")
+        return Basic.__new__(cls, sym, distribution, dim_n, dim_m)
+
+    distribution = property(lambda self: self.args[1])
+    symbol = property(lambda self: self.args[0])
+
+    @property
+    def domain(self):
+        return MatrixDomain(self.symbol, self.distribution.set)
+
+    @property
+    def value(self):
+        return RandomMatrixSymbol(self.symbol, self.args[2], self.args[3], self)
+
+    @property
+    def values(self):
+        return {self.value}
+
+    def compute_density(self, expr, *args):
+        rms = expr.atoms(RandomMatrixSymbol)
+        if len(rms) > 1 or (not isinstance(expr, RandomMatrixSymbol)):
+            raise NotImplementedError("Currently, no algorithm has been "
+                    "implemented to handle general expressions containing "
+                    "multiple matrix distributions.")
+        return self.distribution.pdf(expr)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomMatrixSymbol to realization value.
+        """
+        return {self.value: self.distribution.sample(size, library=library, seed=seed)}
+
+
+def rv(symbol, cls, args):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    dist.check(*args)
+    dim = dist.dimension
+    pspace = MatrixPSpace(symbol, dist, dim[0], dim[1])
+    return pspace.value
+
+
+class SampleMatrixScipy:
+    """Returns the sample from scipy of the given distribution"""
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_scipy(dist, size, seed)
+
+    @classmethod
+    def _sample_scipy(cls, dist, size, seed):
+        """Sample from SciPy."""
+
+        from scipy import stats as scipy_stats
+        import numpy
+        scipy_rv_map = {
+            'WishartDistribution': lambda dist, size, rand_state: scipy_stats.wishart.rvs(
+                df=int(dist.n), scale=matrix2numpy(dist.scale_matrix, float), size=size),
+            'MatrixNormalDistribution': lambda dist, size, rand_state: scipy_stats.matrix_normal.rvs(
+                mean=matrix2numpy(dist.location_matrix, float),
+                rowcov=matrix2numpy(dist.scale_matrix_1, float),
+                colcov=matrix2numpy(dist.scale_matrix_2, float), size=size, random_state=rand_state)
+        }
+
+        sample_shape = {
+            'WishartDistribution': lambda dist: dist.scale_matrix.shape,
+            'MatrixNormalDistribution' : lambda dist: dist.location_matrix.shape
+        }
+
+        dist_list = scipy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        samp = scipy_rv_map[dist.__class__.__name__](dist, prod(size), rand_state)
+        return samp.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+
+class SampleMatrixNumpy:
+    """Returns the sample from numpy of the given distribution"""
+
+    ### TODO: Add tests after adding matrix distributions in numpy_rv_map
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_numpy(dist, size, seed)
+
+    @classmethod
+    def _sample_numpy(cls, dist, size, seed):
+        """Sample from NumPy."""
+
+        numpy_rv_map = {
+        }
+
+        sample_shape = {
+        }
+
+        dist_list = numpy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        import numpy
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        samp = numpy_rv_map[dist.__class__.__name__](dist, prod(size), rand_state)
+        return samp.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+
+class SampleMatrixPymc:
+    """Returns the sample from pymc of the given distribution"""
+
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_pymc(dist, size, seed)
+
+    @classmethod
+    def _sample_pymc(cls, dist, size, seed):
+        """Sample from PyMC."""
+
+        try:
+            import pymc
+        except ImportError:
+            import pymc3 as pymc
+        pymc_rv_map = {
+            'MatrixNormalDistribution': lambda dist: pymc.MatrixNormal('X',
+                mu=matrix2numpy(dist.location_matrix, float),
+                rowcov=matrix2numpy(dist.scale_matrix_1, float),
+                colcov=matrix2numpy(dist.scale_matrix_2, float),
+                shape=dist.location_matrix.shape),
+            'WishartDistribution': lambda dist: pymc.WishartBartlett('X',
+                nu=int(dist.n), S=matrix2numpy(dist.scale_matrix, float))
+        }
+
+        sample_shape = {
+            'WishartDistribution': lambda dist: dist.scale_matrix.shape,
+            'MatrixNormalDistribution' : lambda dist: dist.location_matrix.shape
+        }
+
+        dist_list = pymc_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+        import logging
+        logging.getLogger("pymc").setLevel(logging.ERROR)
+        with pymc.Model():
+            pymc_rv_map[dist.__class__.__name__](dist)
+            samps = pymc.sample(draws=prod(size), chains=1, progressbar=False, random_seed=seed, return_inferencedata=False, compute_convergence_checks=False)['X']
+        return samps.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+_get_sample_class_matrixrv = {
+    'scipy': SampleMatrixScipy,
+    'pymc3': SampleMatrixPymc,
+    'pymc': SampleMatrixPymc,
+    'numpy': SampleMatrixNumpy
+}
+
+################################################################################
+#-------------------------Matrix Distribution----------------------------------#
+################################################################################
+
+class MatrixDistribution(Distribution, NamedArgsMixin):
+    """
+    Abstract class for Matrix Distribution.
+    """
+    def __new__(cls, *args):
+        args = [ImmutableMatrix(arg) if isinstance(arg, list)
+                else _sympify(arg) for arg in args]
+        return Basic.__new__(cls, *args)
+
+    @staticmethod
+    def check(*args):
+        pass
+
+    def __call__(self, expr):
+        if isinstance(expr, list):
+            expr = ImmutableMatrix(expr)
+        return self.pdf(expr)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+
+        libraries = ['scipy', 'numpy', 'pymc3', 'pymc']
+        if library not in libraries:
+            raise NotImplementedError("Sampling from %s is not supported yet."
+                                        % str(library))
+        if not import_module(library):
+            raise ValueError("Failed to import %s" % library)
+
+        samps = _get_sample_class_matrixrv[library](self, size, seed)
+
+        if samps is not None:
+            return samps
+        raise NotImplementedError(
+                "Sampling for %s is not currently implemented from %s"
+                % (self.__class__.__name__, library)
+                )
+
+################################################################################
+#------------------------Matrix Distribution Types-----------------------------#
+################################################################################
+
+#-------------------------------------------------------------------------------
+# Matrix Gamma distribution ----------------------------------------------------
+
+class MatrixGammaDistribution(MatrixDistribution):
+
+    _argnames = ('alpha', 'beta', 'scale_matrix')
+
+    @staticmethod
+    def check(alpha, beta, scale_matrix):
+        if not isinstance(scale_matrix, MatrixSymbol):
+            _value_check(scale_matrix.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        _value_check(scale_matrix.is_square, "Should "
+        "be square matrix")
+        _value_check(alpha.is_positive, "Shape parameter should be positive.")
+        _value_check(beta.is_positive, "Scale parameter should be positive.")
+
+    @property
+    def set(self):
+        k = self.scale_matrix.shape[0]
+        return MatrixSet(k, k, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.scale_matrix.shape
+
+    def pdf(self, x):
+        alpha, beta, scale_matrix = self.alpha, self.beta, self.scale_matrix
+        p = scale_matrix.shape[0]
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                    "or MatrixSymbol" % str(x))
+        sigma_inv_x = - Inverse(scale_matrix)*x / beta
+        term1 = exp(Trace(sigma_inv_x))/((beta**(p*alpha)) * multigamma(alpha, p))
+        term2 = (Determinant(scale_matrix))**(-alpha)
+        term3 = (Determinant(x))**(alpha - S(p + 1)/2)
+        return term1 * term2 * term3
+
+def MatrixGamma(symbol, alpha, beta, scale_matrix):
+    """
+    Creates a random variable with Matrix Gamma Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    alpha: Positive Real number
+        Shape Parameter
+    beta: Positive Real number
+        Scale Parameter
+    scale_matrix: Positive definite real square matrix
+        Scale Matrix
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, MatrixGamma
+    >>> from sympy import MatrixSymbol, symbols
+    >>> a, b = symbols('a b', positive=True)
+    >>> M = MatrixGamma('M', a, b, [[2, 1], [1, 2]])
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(M)(X).doit()
+    exp(Trace(Matrix([
+    [-2/3,  1/3],
+    [ 1/3, -2/3]])*X)/b)*Determinant(X)**(a - 3/2)/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2))
+    >>> density(M)([[1, 0], [0, 1]]).doit()
+    exp(-4/(3*b))/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2))
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_gamma_distribution
+
+    """
+    if isinstance(scale_matrix, list):
+        scale_matrix = ImmutableMatrix(scale_matrix)
+    return rv(symbol, MatrixGammaDistribution, (alpha, beta, scale_matrix))
+
+#-------------------------------------------------------------------------------
+# Wishart Distribution ---------------------------------------------------------
+
+class WishartDistribution(MatrixDistribution):
+
+    _argnames = ('n', 'scale_matrix')
+
+    @staticmethod
+    def check(n, scale_matrix):
+        if not isinstance(scale_matrix, MatrixSymbol):
+            _value_check(scale_matrix.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        _value_check(scale_matrix.is_square, "Should "
+        "be square matrix")
+        _value_check(n.is_positive, "Shape parameter should be positive.")
+
+    @property
+    def set(self):
+        k = self.scale_matrix.shape[0]
+        return MatrixSet(k, k, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.scale_matrix.shape
+
+    def pdf(self, x):
+        n, scale_matrix = self.n, self.scale_matrix
+        p = scale_matrix.shape[0]
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                    "or MatrixSymbol" % str(x))
+        sigma_inv_x = - Inverse(scale_matrix)*x / S(2)
+        term1 = exp(Trace(sigma_inv_x))/((2**(p*n/S(2))) * multigamma(n/S(2), p))
+        term2 = (Determinant(scale_matrix))**(-n/S(2))
+        term3 = (Determinant(x))**(S(n - p - 1)/2)
+        return term1 * term2 * term3
+
+def Wishart(symbol, n, scale_matrix):
+    """
+    Creates a random variable with Wishart Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    n: Positive Real number
+        Represents degrees of freedom
+    scale_matrix: Positive definite real square matrix
+        Scale Matrix
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, Wishart
+    >>> from sympy import MatrixSymbol, symbols
+    >>> n = symbols('n', positive=True)
+    >>> W = Wishart('W', n, [[2, 1], [1, 2]])
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(W)(X).doit()
+    exp(Trace(Matrix([
+    [-1/3,  1/6],
+    [ 1/6, -1/3]])*X))*Determinant(X)**(n/2 - 3/2)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2))
+    >>> density(W)([[1, 0], [0, 1]]).doit()
+    exp(-2/3)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Wishart_distribution
+
+    """
+    if isinstance(scale_matrix, list):
+        scale_matrix = ImmutableMatrix(scale_matrix)
+    return rv(symbol, WishartDistribution, (n, scale_matrix))
+
+#-------------------------------------------------------------------------------
+# Matrix Normal distribution ---------------------------------------------------
+
+class MatrixNormalDistribution(MatrixDistribution):
+
+    _argnames = ('location_matrix', 'scale_matrix_1', 'scale_matrix_2')
+
+    @staticmethod
+    def check(location_matrix, scale_matrix_1, scale_matrix_2):
+        if not isinstance(scale_matrix_1, MatrixSymbol):
+            _value_check(scale_matrix_1.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        if not isinstance(scale_matrix_2, MatrixSymbol):
+            _value_check(scale_matrix_2.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        _value_check(scale_matrix_1.is_square, "Scale matrix 1 should be "
+        "be square matrix")
+        _value_check(scale_matrix_2.is_square, "Scale matrix 2 should be "
+        "be square matrix")
+        n = location_matrix.shape[0]
+        p = location_matrix.shape[1]
+        _value_check(scale_matrix_1.shape[0] == n, "Scale matrix 1 should be"
+        " of shape %s x %s"% (str(n), str(n)))
+        _value_check(scale_matrix_2.shape[0] == p, "Scale matrix 2 should be"
+        " of shape %s x %s"% (str(p), str(p)))
+
+    @property
+    def set(self):
+        n, p = self.location_matrix.shape
+        return MatrixSet(n, p, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.location_matrix.shape
+
+    def pdf(self, x):
+        M, U, V = self.location_matrix, self.scale_matrix_1, self.scale_matrix_2
+        n, p = M.shape
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                    "or MatrixSymbol" % str(x))
+        term1 = Inverse(V)*Transpose(x - M)*Inverse(U)*(x - M)
+        num = exp(-Trace(term1)/S(2))
+        den = (2*pi)**(S(n*p)/2) * Determinant(U)**(S(p)/2) * Determinant(V)**(S(n)/2)
+        return num/den
+
+def MatrixNormal(symbol, location_matrix, scale_matrix_1, scale_matrix_2):
+    """
+    Creates a random variable with Matrix Normal Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    location_matrix: Real ``n x p`` matrix
+        Represents degrees of freedom
+    scale_matrix_1: Positive definite matrix
+        Scale Matrix of shape ``n x n``
+    scale_matrix_2: Positive definite matrix
+        Scale Matrix of shape ``p x p``
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy import MatrixSymbol
+    >>> from sympy.stats import density, MatrixNormal
+    >>> M = MatrixNormal('M', [[1, 2]], [1], [[1, 0], [0, 1]])
+    >>> X = MatrixSymbol('X', 1, 2)
+    >>> density(M)(X).doit()
+    exp(-Trace((Matrix([
+    [-1],
+    [-2]]) + X.T)*(Matrix([[-1, -2]]) + X))/2)/(2*pi)
+    >>> density(M)([[3, 4]]).doit()
+    exp(-4)/(2*pi)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_normal_distribution
+
+    """
+    if isinstance(location_matrix, list):
+        location_matrix = ImmutableMatrix(location_matrix)
+    if isinstance(scale_matrix_1, list):
+        scale_matrix_1 = ImmutableMatrix(scale_matrix_1)
+    if isinstance(scale_matrix_2, list):
+        scale_matrix_2 = ImmutableMatrix(scale_matrix_2)
+    args = (location_matrix, scale_matrix_1, scale_matrix_2)
+    return rv(symbol, MatrixNormalDistribution, args)
+
+#-------------------------------------------------------------------------------
+# Matrix Student's T distribution ---------------------------------------------------
+
+class MatrixStudentTDistribution(MatrixDistribution):
+
+    _argnames = ('nu', 'location_matrix', 'scale_matrix_1', 'scale_matrix_2')
+
+    @staticmethod
+    def check(nu, location_matrix, scale_matrix_1, scale_matrix_2):
+        if not isinstance(scale_matrix_1, MatrixSymbol):
+            _value_check(scale_matrix_1.is_positive_definite != False, "The shape "
+                                                              "matrix must be positive definite.")
+        if not isinstance(scale_matrix_2, MatrixSymbol):
+            _value_check(scale_matrix_2.is_positive_definite != False, "The shape "
+                                                              "matrix must be positive definite.")
+        _value_check(scale_matrix_1.is_square != False, "Scale matrix 1 should be "
+                                               "be square matrix")
+        _value_check(scale_matrix_2.is_square != False, "Scale matrix 2 should be "
+                                               "be square matrix")
+        n = location_matrix.shape[0]
+        p = location_matrix.shape[1]
+        _value_check(scale_matrix_1.shape[0] == p, "Scale matrix 1 should be"
+                                                   " of shape %s x %s" % (str(p), str(p)))
+        _value_check(scale_matrix_2.shape[0] == n, "Scale matrix 2 should be"
+                                                   " of shape %s x %s" % (str(n), str(n)))
+        _value_check(nu.is_positive != False, "Degrees of freedom must be positive")
+
+    @property
+    def set(self):
+        n, p = self.location_matrix.shape
+        return MatrixSet(n, p, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.location_matrix.shape
+
+    def pdf(self, x):
+        from sympy.matrices.dense import eye
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                             "or MatrixSymbol" % str(x))
+        nu, M, Omega, Sigma = self.nu, self.location_matrix, self.scale_matrix_1, self.scale_matrix_2
+        n, p = M.shape
+
+        K = multigamma((nu + n + p - 1)/2, p) * Determinant(Omega)**(-n/2) * Determinant(Sigma)**(-p/2) \
+            / ((pi)**(n*p/2) * multigamma((nu + p - 1)/2, p))
+        return K * (Determinant(eye(n) + Inverse(Sigma)*(x - M)*Inverse(Omega)*Transpose(x - M))) \
+               **(-(nu + n + p -1)/2)
+
+
+
+def MatrixStudentT(symbol, nu, location_matrix, scale_matrix_1, scale_matrix_2):
+    """
+    Creates a random variable with Matrix Gamma Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    nu: Positive Real number
+        degrees of freedom
+    location_matrix: Positive definite real square matrix
+        Location Matrix of shape ``n x p``
+    scale_matrix_1: Positive definite real square matrix
+        Scale Matrix of shape ``p x p``
+    scale_matrix_2: Positive definite real square matrix
+        Scale Matrix of shape ``n x n``
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy import MatrixSymbol,symbols
+    >>> from sympy.stats import density, MatrixStudentT
+    >>> v = symbols('v',positive=True)
+    >>> M = MatrixStudentT('M', v, [[1, 2]], [[1, 0], [0, 1]], [1])
+    >>> X = MatrixSymbol('X', 1, 2)
+    >>> density(M)(X)
+    gamma(v/2 + 1)*Determinant((Matrix([[-1, -2]]) + X)*(Matrix([
+    [-1],
+    [-2]]) + X.T) + Matrix([[1]]))**(-v/2 - 1)/(pi**1.0*gamma(v/2)*Determinant(Matrix([[1]]))**1.0*Determinant(Matrix([
+    [1, 0],
+    [0, 1]]))**0.5)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_t-distribution
+
+    """
+    if isinstance(location_matrix, list):
+        location_matrix = ImmutableMatrix(location_matrix)
+    if isinstance(scale_matrix_1, list):
+        scale_matrix_1 = ImmutableMatrix(scale_matrix_1)
+    if isinstance(scale_matrix_2, list):
+        scale_matrix_2 = ImmutableMatrix(scale_matrix_2)
+    args = (nu, location_matrix, scale_matrix_1, scale_matrix_2)
+    return rv(symbol, MatrixStudentTDistribution, args)

venv/lib/python3.10/site-packages/sympy/stats/random_matrix.py

@@ -0,0 +1,30 @@
+from sympy.core.basic import Basic
+from sympy.stats.rv import PSpace, _symbol_converter, RandomMatrixSymbol
+
+class RandomMatrixPSpace(PSpace):
+    """
+    Represents probability space for
+    random matrices. It contains the mechanics
+    for handling the API calls for random matrices.
+    """
+    def __new__(cls, sym, model=None):
+        sym = _symbol_converter(sym)
+        if model:
+            return Basic.__new__(cls, sym, model)
+        else:
+            return Basic.__new__(cls, sym)
+
+    @property
+    def model(self):
+        try:
+            return self.args[1]
+        except IndexError:
+            return None
+
+    def compute_density(self, expr, *args):
+        rms = expr.atoms(RandomMatrixSymbol)
+        if len(rms) > 2 or (not isinstance(expr, RandomMatrixSymbol)):
+            raise NotImplementedError("Currently, no algorithm has been "
+                    "implemented to handle general expressions containing "
+                    "multiple random matrices.")
+        return self.model.density(expr)

venv/lib/python3.10/site-packages/sympy/stats/random_matrix_models.py

@@ -0,0 +1,457 @@
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.numbers import (I, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.trace import Trace
+from sympy.tensor.indexed import IndexedBase
+from sympy.core.sympify import _sympify
+from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol, is_random
+from sympy.stats.joint_rv_types import JointDistributionHandmade
+from sympy.stats.random_matrix import RandomMatrixPSpace
+from sympy.tensor.array import ArrayComprehension
+
+__all__ = [
+    'CircularEnsemble',
+    'CircularUnitaryEnsemble',
+    'CircularOrthogonalEnsemble',
+    'CircularSymplecticEnsemble',
+    'GaussianEnsemble',
+    'GaussianUnitaryEnsemble',
+    'GaussianOrthogonalEnsemble',
+    'GaussianSymplecticEnsemble',
+    'joint_eigen_distribution',
+    'JointEigenDistribution',
+    'level_spacing_distribution'
+]
+
+@is_random.register(RandomMatrixSymbol)
+def _(x):
+    return True
+
+
+class RandomMatrixEnsembleModel(Basic):
+    """
+    Base class for random matrix ensembles.
+    It acts as an umbrella and contains
+    the methods common to all the ensembles
+    defined in sympy.stats.random_matrix_models.
+    """
+    def __new__(cls, sym, dim=None):
+        sym, dim = _symbol_converter(sym), _sympify(dim)
+        if dim.is_integer == False:
+            raise ValueError("Dimension of the random matrices must be "
+                                "integers, received %s instead."%(dim))
+        return Basic.__new__(cls, sym, dim)
+
+    symbol = property(lambda self: self.args[0])
+    dimension = property(lambda self: self.args[1])
+
+    def density(self, expr):
+        return Density(expr)
+
+    def __call__(self, expr):
+        return self.density(expr)
+
+class GaussianEnsembleModel(RandomMatrixEnsembleModel):
+    """
+    Abstract class for Gaussian ensembles.
+    Contains the properties common to all the
+    gaussian ensembles.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles
+    .. [2] https://arxiv.org/pdf/1712.07903.pdf
+    """
+    def _compute_normalization_constant(self, beta, n):
+        """
+        Helper function for computing normalization
+        constant for joint probability density of eigen
+        values of Gaussian ensembles.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral
+        """
+        n = S(n)
+        prod_term = lambda j: gamma(1 + beta*S(j)/2)/gamma(S.One + beta/S(2))
+        j = Dummy('j', integer=True, positive=True)
+        term1 = Product(prod_term(j), (j, 1, n)).doit()
+        term2 = (2/(beta*n))**(beta*n*(n - 1)/4 + n/2)
+        term3 = (2*pi)**(n/2)
+        return term1 * term2 * term3
+
+    def _compute_joint_eigen_distribution(self, beta):
+        """
+        Helper function for computing the joint
+        probability distribution of eigen values
+        of the random matrix.
+        """
+        n = self.dimension
+        Zbn = self._compute_normalization_constant(beta, n)
+        l = IndexedBase('l')
+        i = Dummy('i', integer=True, positive=True)
+        j = Dummy('j', integer=True, positive=True)
+        k = Dummy('k', integer=True, positive=True)
+        term1 = exp((-S(n)/2) * Sum(l[k]**2, (k, 1, n)).doit())
+        sub_term = Lambda(i, Product(Abs(l[j] - l[i])**beta, (j, i + 1, n)))
+        term2 = Product(sub_term(i).doit(), (i, 1, n - 1)).doit()
+        syms = ArrayComprehension(l[k], (k, 1, n)).doit()
+        return Lambda(tuple(syms), (term1 * term2)/Zbn)
+
+class GaussianUnitaryEnsembleModel(GaussianEnsembleModel):
+    @property
+    def normalization_constant(self):
+        n = self.dimension
+        return 2**(S(n)/2) * pi**(S(n**2)/2)
+
+    def density(self, expr):
+        n, ZGUE = self.dimension, self.normalization_constant
+        h_pspace = RandomMatrixPSpace('P', model=self)
+        H = RandomMatrixSymbol('H', n, n, pspace=h_pspace)
+        return Lambda(H, exp(-S(n)/2 * Trace(H**2))/ZGUE)(expr)
+
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(2))
+
+    def level_spacing_distribution(self):
+        s = Dummy('s')
+        f = (32/pi**2)*(s**2)*exp((-4/pi)*s**2)
+        return Lambda(s, f)
+
+class GaussianOrthogonalEnsembleModel(GaussianEnsembleModel):
+    @property
+    def normalization_constant(self):
+        n = self.dimension
+        _H = MatrixSymbol('_H', n, n)
+        return Integral(exp(-S(n)/4 * Trace(_H**2)))
+
+    def density(self, expr):
+        n, ZGOE = self.dimension, self.normalization_constant
+        h_pspace = RandomMatrixPSpace('P', model=self)
+        H = RandomMatrixSymbol('H', n, n, pspace=h_pspace)
+        return Lambda(H, exp(-S(n)/4 * Trace(H**2))/ZGOE)(expr)
+
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S.One)
+
+    def level_spacing_distribution(self):
+        s = Dummy('s')
+        f = (pi/2)*s*exp((-pi/4)*s**2)
+        return Lambda(s, f)
+
+class GaussianSymplecticEnsembleModel(GaussianEnsembleModel):
+    @property
+    def normalization_constant(self):
+        n = self.dimension
+        _H = MatrixSymbol('_H', n, n)
+        return Integral(exp(-S(n) * Trace(_H**2)))
+
+    def density(self, expr):
+        n, ZGSE = self.dimension, self.normalization_constant
+        h_pspace = RandomMatrixPSpace('P', model=self)
+        H = RandomMatrixSymbol('H', n, n, pspace=h_pspace)
+        return Lambda(H, exp(-S(n) * Trace(H**2))/ZGSE)(expr)
+
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(4))
+
+    def level_spacing_distribution(self):
+        s = Dummy('s')
+        f = ((S(2)**18)/((S(3)**6)*(pi**3)))*(s**4)*exp((-64/(9*pi))*s**2)
+        return Lambda(s, f)
+
+def GaussianEnsemble(sym, dim):
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def GaussianUnitaryEnsemble(sym, dim):
+    """
+    Represents Gaussian Unitary Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density
+    >>> from sympy import MatrixSymbol
+    >>> G = GUE('U', 2)
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(G)(X)
+    exp(-Trace(X**2))/(2*pi**2)
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianUnitaryEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def GaussianOrthogonalEnsemble(sym, dim):
+    """
+    Represents Gaussian Orthogonal Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density
+    >>> from sympy import MatrixSymbol
+    >>> G = GOE('U', 2)
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(G)(X)
+    exp(-Trace(X**2)/2)/Integral(exp(-Trace(_H**2)/2), _H)
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianOrthogonalEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def GaussianSymplecticEnsemble(sym, dim):
+    """
+    Represents Gaussian Symplectic Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density
+    >>> from sympy import MatrixSymbol
+    >>> G = GSE('U', 2)
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(G)(X)
+    exp(-2*Trace(X**2))/Integral(exp(-2*Trace(_H**2)), _H)
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianSymplecticEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+class CircularEnsembleModel(RandomMatrixEnsembleModel):
+    """
+    Abstract class for Circular ensembles.
+    Contains the properties and methods
+    common to all the circular ensembles.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Circular_ensemble
+    """
+    def density(self, expr):
+        # TODO : Add support for Lie groups(as extensions of sympy.diffgeom)
+        #        and define measures on them
+        raise NotImplementedError("Support for Haar measure hasn't been "
+                                  "implemented yet, therefore the density of "
+                                  "%s cannot be computed."%(self))
+
+    def _compute_joint_eigen_distribution(self, beta):
+        """
+        Helper function to compute the joint distribution of phases
+        of the complex eigen values of matrices belonging to any
+        circular ensembles.
+        """
+        n = self.dimension
+        Zbn = ((2*pi)**n)*(gamma(beta*n/2 + 1)/S(gamma(beta/2 + 1))**n)
+        t = IndexedBase('t')
+        i, j, k = (Dummy('i', integer=True), Dummy('j', integer=True),
+                   Dummy('k', integer=True))
+        syms = ArrayComprehension(t[i], (i, 1, n)).doit()
+        f = Product(Product(Abs(exp(I*t[k]) - exp(I*t[j]))**beta, (j, k + 1, n)).doit(),
+                    (k, 1, n - 1)).doit()
+        return Lambda(tuple(syms), f/Zbn)
+
+class CircularUnitaryEnsembleModel(CircularEnsembleModel):
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(2))
+
+class CircularOrthogonalEnsembleModel(CircularEnsembleModel):
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S.One)
+
+class CircularSymplecticEnsembleModel(CircularEnsembleModel):
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(4))
+
+def CircularEnsemble(sym, dim):
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def CircularUnitaryEnsemble(sym, dim):
+    """
+    Represents Circular Unitary Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import CircularUnitaryEnsemble as CUE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> C = CUE('U', 1)
+    >>> joint_eigen_distribution(C)
+    Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**2, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi))
+
+    Note
+    ====
+
+    As can be seen above in the example, density of CiruclarUnitaryEnsemble
+    is not evaluated because the exact definition is based on haar measure of
+    unitary group which is not unique.
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularUnitaryEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def CircularOrthogonalEnsemble(sym, dim):
+    """
+    Represents Circular Orthogonal Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import CircularOrthogonalEnsemble as COE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> C = COE('O', 1)
+    >>> joint_eigen_distribution(C)
+    Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2*pi))
+
+    Note
+    ====
+
+    As can be seen above in the example, density of CiruclarOrthogonalEnsemble
+    is not evaluated because the exact definition is based on haar measure of
+    unitary group which is not unique.
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularOrthogonalEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def CircularSymplecticEnsemble(sym, dim):
+    """
+    Represents Circular Symplectic Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import CircularSymplecticEnsemble as CSE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> C = CSE('S', 1)
+    >>> joint_eigen_distribution(C)
+    Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**4, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi))
+
+    Note
+    ====
+
+    As can be seen above in the example, density of CiruclarSymplecticEnsemble
+    is not evaluated because the exact definition is based on haar measure of
+    unitary group which is not unique.
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularSymplecticEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def joint_eigen_distribution(mat):
+    """
+    For obtaining joint probability distribution
+    of eigen values of random matrix.
+
+    Parameters
+    ==========
+
+    mat: RandomMatrixSymbol
+        The matrix symbol whose eigen values are to be considered.
+
+    Returns
+    =======
+
+    Lambda
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianUnitaryEnsemble as GUE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> U = GUE('U', 2)
+    >>> joint_eigen_distribution(U)
+    Lambda((l[1], l[2]), exp(-l[1]**2 - l[2]**2)*Product(Abs(l[_i] - l[_j])**2, (_j, _i + 1, 2), (_i, 1, 1))/pi)
+    """
+    if not isinstance(mat, RandomMatrixSymbol):
+        raise ValueError("%s is not of type, RandomMatrixSymbol."%(mat))
+    return mat.pspace.model.joint_eigen_distribution()
+
+def JointEigenDistribution(mat):
+    """
+    Creates joint distribution of eigen values of matrices with random
+    expressions.
+
+    Parameters
+    ==========
+
+    mat: Matrix
+        The matrix under consideration.
+
+    Returns
+    =======
+
+    JointDistributionHandmade
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, JointEigenDistribution
+    >>> from sympy import Matrix
+    >>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)],
+    ... [Normal('A10', 0, 1), Normal('A11', 0, 1)]]
+    >>> JointEigenDistribution(Matrix(A))
+    JointDistributionHandmade(-sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2
+    + A00/2 + A11/2, sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + A00/2 + A11/2)
+
+    """
+    eigenvals = mat.eigenvals(multiple=True)
+    if not all(is_random(eigenval) for eigenval in set(eigenvals)):
+        raise ValueError("Eigen values do not have any random expression, "
+                         "joint distribution cannot be generated.")
+    return JointDistributionHandmade(*eigenvals)
+
+def level_spacing_distribution(mat):
+    """
+    For obtaining distribution of level spacings.
+
+    Parameters
+    ==========
+
+    mat: RandomMatrixSymbol
+        The random matrix symbol whose eigen values are
+        to be considered for finding the level spacings.
+
+    Returns
+    =======
+
+    Lambda
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianUnitaryEnsemble as GUE
+    >>> from sympy.stats import level_spacing_distribution
+    >>> U = GUE('U', 2)
+    >>> level_spacing_distribution(U)
+    Lambda(_s, 32*_s**2*exp(-4*_s**2/pi)/pi**2)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings
+    """
+    return mat.pspace.model.level_spacing_distribution()

venv/lib/python3.10/site-packages/sympy/stats/rv.py

@@ -0,0 +1,1792 @@
+"""
+Main Random Variables Module
+
+Defines abstract random variable type.
+Contains interfaces for probability space object (PSpace) as well as standard
+operators, P, E, sample, density, where, quantile
+
+See Also
+========
+
+sympy.stats.crv
+sympy.stats.frv
+sympy.stats.rv_interface
+"""
+
+from __future__ import annotations
+from functools import singledispatch
+from math import prod
+
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import (Function, Lambda)
+from sympy.core.logic import fuzzy_and
+from sympy.core.mul import Mul
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.core.sympify import sympify
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.tensor.indexed import Indexed
+from sympy.utilities.lambdify import lambdify
+from sympy.core.relational import Relational
+from sympy.core.sympify import _sympify
+from sympy.sets.sets import FiniteSet, ProductSet, Intersection
+from sympy.solvers.solveset import solveset
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable
+
+
+x = Symbol('x')
+
+@singledispatch
+def is_random(x):
+    return False
+
+@is_random.register(Basic)
+def _(x):
+    atoms = x.free_symbols
+    return any(is_random(i) for i in atoms)
+
+class RandomDomain(Basic):
+    """
+    Represents a set of variables and the values which they can take.
+
+    See Also
+    ========
+
+    sympy.stats.crv.ContinuousDomain
+    sympy.stats.frv.FiniteDomain
+    """
+
+    is_ProductDomain = False
+    is_Finite = False
+    is_Continuous = False
+    is_Discrete = False
+
+    def __new__(cls, symbols, *args):
+        symbols = FiniteSet(*symbols)
+        return Basic.__new__(cls, symbols, *args)
+
+    @property
+    def symbols(self):
+        return self.args[0]
+
+    @property
+    def set(self):
+        return self.args[1]
+
+    def __contains__(self, other):
+        raise NotImplementedError()
+
+    def compute_expectation(self, expr):
+        raise NotImplementedError()
+
+
+class SingleDomain(RandomDomain):
+    """
+    A single variable and its domain.
+
+    See Also
+    ========
+
+    sympy.stats.crv.SingleContinuousDomain
+    sympy.stats.frv.SingleFiniteDomain
+    """
+    def __new__(cls, symbol, set):
+        assert symbol.is_Symbol
+        return Basic.__new__(cls, symbol, set)
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def symbols(self):
+        return FiniteSet(self.symbol)
+
+    def __contains__(self, other):
+        if len(other) != 1:
+            return False
+        sym, val = tuple(other)[0]
+        return self.symbol == sym and val in self.set
+
+
+class MatrixDomain(RandomDomain):
+    """
+    A Random Matrix variable and its domain.
+
+    """
+    def __new__(cls, symbol, set):
+        symbol, set = _symbol_converter(symbol), _sympify(set)
+        return Basic.__new__(cls, symbol, set)
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def symbols(self):
+        return FiniteSet(self.symbol)
+
+
+class ConditionalDomain(RandomDomain):
+    """
+    A RandomDomain with an attached condition.
+
+    See Also
+    ========
+
+    sympy.stats.crv.ConditionalContinuousDomain
+    sympy.stats.frv.ConditionalFiniteDomain
+    """
+    def __new__(cls, fulldomain, condition):
+        condition = condition.xreplace({rs: rs.symbol
+            for rs in random_symbols(condition)})
+        return Basic.__new__(cls, fulldomain, condition)
+
+    @property
+    def symbols(self):
+        return self.fulldomain.symbols
+
+    @property
+    def fulldomain(self):
+        return self.args[0]
+
+    @property
+    def condition(self):
+        return self.args[1]
+
+    @property
+    def set(self):
+        raise NotImplementedError("Set of Conditional Domain not Implemented")
+
+    def as_boolean(self):
+        return And(self.fulldomain.as_boolean(), self.condition)
+
+
+class PSpace(Basic):
+    """
+    A Probability Space.
+
+    Explanation
+    ===========
+
+    Probability Spaces encode processes that equal different values
+    probabilistically. These underly Random Symbols which occur in SymPy
+    expressions and contain the mechanics to evaluate statistical statements.
+
+    See Also
+    ========
+
+    sympy.stats.crv.ContinuousPSpace
+    sympy.stats.frv.FinitePSpace
+    """
+
+    is_Finite = None  # type: bool
+    is_Continuous = None  # type: bool
+    is_Discrete = None  # type: bool
+    is_real = None  # type: bool
+
+    @property
+    def domain(self):
+        return self.args[0]
+
+    @property
+    def density(self):
+        return self.args[1]
+
+    @property
+    def values(self):
+        return frozenset(RandomSymbol(sym, self) for sym in self.symbols)
+
+    @property
+    def symbols(self):
+        return self.domain.symbols
+
+    def where(self, condition):
+        raise NotImplementedError()
+
+    def compute_density(self, expr):
+        raise NotImplementedError()
+
+    def sample(self, size=(), library='scipy', seed=None):
+        raise NotImplementedError()
+
+    def probability(self, condition):
+        raise NotImplementedError()
+
+    def compute_expectation(self, expr):
+        raise NotImplementedError()
+
+
+class SinglePSpace(PSpace):
+    """
+    Represents the probabilities of a set of random events that can be
+    attributed to a single variable/symbol.
+    """
+    def __new__(cls, s, distribution):
+        s = _symbol_converter(s)
+        return Basic.__new__(cls, s, distribution)
+
+    @property
+    def value(self):
+        return RandomSymbol(self.symbol, self)
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def distribution(self):
+        return self.args[1]
+
+    @property
+    def pdf(self):
+        return self.distribution.pdf(self.symbol)
+
+
+class RandomSymbol(Expr):
+    """
+    Random Symbols represent ProbabilitySpaces in SymPy Expressions.
+    In principle they can take on any value that their symbol can take on
+    within the associated PSpace with probability determined by the PSpace
+    Density.
+
+    Explanation
+    ===========
+
+    Random Symbols contain pspace and symbol properties.
+    The pspace property points to the represented Probability Space
+    The symbol is a standard SymPy Symbol that is used in that probability space
+    for example in defining a density.
+
+    You can form normal SymPy expressions using RandomSymbols and operate on
+    those expressions with the Functions
+
+    E - Expectation of a random expression
+    P - Probability of a condition
+    density - Probability Density of an expression
+    given - A new random expression (with new random symbols) given a condition
+
+    An object of the RandomSymbol type should almost never be created by the
+    user. They tend to be created instead by the PSpace class's value method.
+    Traditionally a user does not even do this but instead calls one of the
+    convenience functions Normal, Exponential, Coin, Die, FiniteRV, etc....
+    """
+
+    def __new__(cls, symbol, pspace=None):
+        from sympy.stats.joint_rv import JointRandomSymbol
+        if pspace is None:
+            # Allow single arg, representing pspace == PSpace()
+            pspace = PSpace()
+        symbol = _symbol_converter(symbol)
+        if not isinstance(pspace, PSpace):
+            raise TypeError("pspace variable should be of type PSpace")
+        if cls == JointRandomSymbol and isinstance(pspace, SinglePSpace):
+            cls = RandomSymbol
+        return Basic.__new__(cls, symbol, pspace)
+
+    is_finite = True
+    is_symbol = True
+    is_Atom = True
+
+    _diff_wrt = True
+
+    pspace = property(lambda self: self.args[1])
+    symbol = property(lambda self: self.args[0])
+    name   = property(lambda self: self.symbol.name)
+
+    def _eval_is_positive(self):
+        return self.symbol.is_positive
+
+    def _eval_is_integer(self):
+        return self.symbol.is_integer
+
+    def _eval_is_real(self):
+        return self.symbol.is_real or self.pspace.is_real
+
+    @property
+    def is_commutative(self):
+        return self.symbol.is_commutative
+
+    @property
+    def free_symbols(self):
+        return {self}
+
+class RandomIndexedSymbol(RandomSymbol):
+
+    def __new__(cls, idx_obj, pspace=None):
+        if pspace is None:
+            # Allow single arg, representing pspace == PSpace()
+            pspace = PSpace()
+        if not isinstance(idx_obj, (Indexed, Function)):
+            raise TypeError("An Function or Indexed object is expected not %s"%(idx_obj))
+        return Basic.__new__(cls, idx_obj, pspace)
+
+    symbol = property(lambda self: self.args[0])
+    name = property(lambda self: str(self.args[0]))
+
+    @property
+    def key(self):
+        if isinstance(self.symbol, Indexed):
+            return self.symbol.args[1]
+        elif isinstance(self.symbol, Function):
+            return self.symbol.args[0]
+
+    @property
+    def free_symbols(self):
+        if self.key.free_symbols:
+            free_syms = self.key.free_symbols
+            free_syms.add(self)
+            return free_syms
+        return {self}
+
+    @property
+    def pspace(self):
+        return self.args[1]
+
+class RandomMatrixSymbol(RandomSymbol, MatrixSymbol): # type: ignore
+    def __new__(cls, symbol, n, m, pspace=None):
+        n, m = _sympify(n), _sympify(m)
+        symbol = _symbol_converter(symbol)
+        if pspace is None:
+            # Allow single arg, representing pspace == PSpace()
+            pspace = PSpace()
+        return Basic.__new__(cls, symbol, n, m, pspace)
+
+    symbol = property(lambda self: self.args[0])
+    pspace = property(lambda self: self.args[3])
+
+
+class ProductPSpace(PSpace):
+    """
+    Abstract class for representing probability spaces with multiple random
+    variables.
+
+    See Also
+    ========
+
+    sympy.stats.rv.IndependentProductPSpace
+    sympy.stats.joint_rv.JointPSpace
+    """
+    pass
+
+class IndependentProductPSpace(ProductPSpace):
+    """
+    A probability space resulting from the merger of two independent probability
+    spaces.
+
+    Often created using the function, pspace.
+    """
+
+    def __new__(cls, *spaces):
+        rs_space_dict = {}
+        for space in spaces:
+            for value in space.values:
+                rs_space_dict[value] = space
+
+        symbols = FiniteSet(*[val.symbol for val in rs_space_dict.keys()])
+
+        # Overlapping symbols
+        from sympy.stats.joint_rv import MarginalDistribution
+        from sympy.stats.compound_rv import CompoundDistribution
+        if len(symbols) < sum(len(space.symbols) for space in spaces if not
+         isinstance(space.distribution, (
+            CompoundDistribution, MarginalDistribution))):
+            raise ValueError("Overlapping Random Variables")
+
+        if all(space.is_Finite for space in spaces):
+            from sympy.stats.frv import ProductFinitePSpace
+            cls = ProductFinitePSpace
+
+        obj = Basic.__new__(cls, *FiniteSet(*spaces))
+
+        return obj
+
+    @property
+    def pdf(self):
+        p = Mul(*[space.pdf for space in self.spaces])
+        return p.subs({rv: rv.symbol for rv in self.values})
+
+    @property
+    def rs_space_dict(self):
+        d = {}
+        for space in self.spaces:
+            for value in space.values:
+                d[value] = space
+        return d
+
+    @property
+    def symbols(self):
+        return FiniteSet(*[val.symbol for val in self.rs_space_dict.keys()])
+
+    @property
+    def spaces(self):
+        return FiniteSet(*self.args)
+
+    @property
+    def values(self):
+        return sumsets(space.values for space in self.spaces)
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        rvs = rvs or self.values
+        rvs = frozenset(rvs)
+        for space in self.spaces:
+            expr = space.compute_expectation(expr, rvs & space.values, evaluate=False, **kwargs)
+        if evaluate and hasattr(expr, 'doit'):
+            return expr.doit(**kwargs)
+        return expr
+
+    @property
+    def domain(self):
+        return ProductDomain(*[space.domain for space in self.spaces])
+
+    @property
+    def density(self):
+        raise NotImplementedError("Density not available for ProductSpaces")
+
+    def sample(self, size=(), library='scipy', seed=None):
+        return {k: v for space in self.spaces
+            for k, v in space.sample(size=size, library=library, seed=seed).items()}
+
+
+    def probability(self, condition, **kwargs):
+        cond_inv = False
+        if isinstance(condition, Ne):
+            condition = Eq(condition.args[0], condition.args[1])
+            cond_inv = True
+        elif isinstance(condition, And): # they are independent
+            return Mul(*[self.probability(arg) for arg in condition.args])
+        elif isinstance(condition, Or): # they are independent
+            return Add(*[self.probability(arg) for arg in condition.args])
+        expr = condition.lhs - condition.rhs
+        rvs = random_symbols(expr)
+        dens = self.compute_density(expr)
+        if any(pspace(rv).is_Continuous for rv in rvs):
+            from sympy.stats.crv import SingleContinuousPSpace
+            from sympy.stats.crv_types import ContinuousDistributionHandmade
+            if expr in self.values:
+                # Marginalize all other random symbols out of the density
+                randomsymbols = tuple(set(self.values) - frozenset([expr]))
+                symbols = tuple(rs.symbol for rs in randomsymbols)
+                pdf = self.domain.integrate(self.pdf, symbols, **kwargs)
+                return Lambda(expr.symbol, pdf)
+            dens = ContinuousDistributionHandmade(dens)
+            z = Dummy('z', real=True)
+            space = SingleContinuousPSpace(z, dens)
+            result = space.probability(condition.__class__(space.value, 0))
+        else:
+            from sympy.stats.drv import SingleDiscretePSpace
+            from sympy.stats.drv_types import DiscreteDistributionHandmade
+            dens = DiscreteDistributionHandmade(dens)
+            z = Dummy('z', integer=True)
+            space = SingleDiscretePSpace(z, dens)
+            result = space.probability(condition.__class__(space.value, 0))
+        return result if not cond_inv else S.One - result
+
+    def compute_density(self, expr, **kwargs):
+        rvs = random_symbols(expr)
+        if any(pspace(rv).is_Continuous for rv in rvs):
+            z = Dummy('z', real=True)
+            expr = self.compute_expectation(DiracDelta(expr - z),
+             **kwargs)
+        else:
+            z = Dummy('z', integer=True)
+            expr = self.compute_expectation(KroneckerDelta(expr, z),
+             **kwargs)
+        return Lambda(z, expr)
+
+    def compute_cdf(self, expr, **kwargs):
+        raise ValueError("CDF not well defined on multivariate expressions")
+
+    def conditional_space(self, condition, normalize=True, **kwargs):
+        rvs = random_symbols(condition)
+        condition = condition.xreplace({rv: rv.symbol for rv in self.values})
+        pspaces = [pspace(rv) for rv in rvs]
+        if any(ps.is_Continuous for ps in pspaces):
+            from sympy.stats.crv import (ConditionalContinuousDomain,
+                ContinuousPSpace)
+            space = ContinuousPSpace
+            domain = ConditionalContinuousDomain(self.domain, condition)
+        elif any(ps.is_Discrete for ps in pspaces):
+            from sympy.stats.drv import (ConditionalDiscreteDomain,
+                DiscretePSpace)
+            space = DiscretePSpace
+            domain = ConditionalDiscreteDomain(self.domain, condition)
+        elif all(ps.is_Finite for ps in pspaces):
+            from sympy.stats.frv import FinitePSpace
+            return FinitePSpace.conditional_space(self, condition)
+        if normalize:
+            replacement  = {rv: Dummy(str(rv)) for rv in self.symbols}
+            norm = domain.compute_expectation(self.pdf, **kwargs)
+            pdf = self.pdf / norm.xreplace(replacement)
+            # XXX: Converting symbols from set to tuple. The order matters to
+            # Lambda though so we shouldn't be starting with a set here...
+            density = Lambda(tuple(domain.symbols), pdf)
+
+        return space(domain, density)
+
+class ProductDomain(RandomDomain):
+    """
+    A domain resulting from the merger of two independent domains.
+
+    See Also
+    ========
+    sympy.stats.crv.ProductContinuousDomain
+    sympy.stats.frv.ProductFiniteDomain
+    """
+    is_ProductDomain = True
+
+    def __new__(cls, *domains):
+        # Flatten any product of products
+        domains2 = []
+        for domain in domains:
+            if not domain.is_ProductDomain:
+                domains2.append(domain)
+            else:
+                domains2.extend(domain.domains)
+        domains2 = FiniteSet(*domains2)
+
+        if all(domain.is_Finite for domain in domains2):
+            from sympy.stats.frv import ProductFiniteDomain
+            cls = ProductFiniteDomain
+        if all(domain.is_Continuous for domain in domains2):
+            from sympy.stats.crv import ProductContinuousDomain
+            cls = ProductContinuousDomain
+        if all(domain.is_Discrete for domain in domains2):
+            from sympy.stats.drv import ProductDiscreteDomain
+            cls = ProductDiscreteDomain
+
+        return Basic.__new__(cls, *domains2)
+
+    @property
+    def sym_domain_dict(self):
+        return {symbol: domain for domain in self.domains
+                                     for symbol in domain.symbols}
+
+    @property
+    def symbols(self):
+        return FiniteSet(*[sym for domain in self.domains
+                               for sym    in domain.symbols])
+
+    @property
+    def domains(self):
+        return self.args
+
+    @property
+    def set(self):
+        return ProductSet(*(domain.set for domain in self.domains))
+
+    def __contains__(self, other):
+        # Split event into each subdomain
+        for domain in self.domains:
+            # Collect the parts of this event which associate to this domain
+            elem = frozenset([item for item in other
+                              if sympify(domain.symbols.contains(item[0]))
+                              is S.true])
+            # Test this sub-event
+            if elem not in domain:
+                return False
+        # All subevents passed
+        return True
+
+    def as_boolean(self):
+        return And(*[domain.as_boolean() for domain in self.domains])
+
+
+def random_symbols(expr):
+    """
+    Returns all RandomSymbols within a SymPy Expression.
+    """
+    atoms = getattr(expr, 'atoms', None)
+    if atoms is not None:
+        comp = lambda rv: rv.symbol.name
+        l = list(atoms(RandomSymbol))
+        return sorted(l, key=comp)
+    else:
+        return []
+
+
+def pspace(expr):
+    """
+    Returns the underlying Probability Space of a random expression.
+
+    For internal use.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import pspace, Normal
+    >>> X = Normal('X', 0, 1)
+    >>> pspace(2*X + 1) == X.pspace
+    True
+    """
+    expr = sympify(expr)
+    if isinstance(expr, RandomSymbol) and expr.pspace is not None:
+        return expr.pspace
+    if expr.has(RandomMatrixSymbol):
+        rm = list(expr.atoms(RandomMatrixSymbol))[0]
+        return rm.pspace
+
+    rvs = random_symbols(expr)
+    if not rvs:
+        raise ValueError("Expression containing Random Variable expected, not %s" % (expr))
+    # If only one space present
+    if all(rv.pspace == rvs[0].pspace for rv in rvs):
+        return rvs[0].pspace
+    from sympy.stats.compound_rv import CompoundPSpace
+    from sympy.stats.stochastic_process import StochasticPSpace
+    for rv in rvs:
+        if isinstance(rv.pspace, (CompoundPSpace, StochasticPSpace)):
+            return rv.pspace
+    # Otherwise make a product space
+    return IndependentProductPSpace(*[rv.pspace for rv in rvs])
+
+
+def sumsets(sets):
+    """
+    Union of sets
+    """
+    return frozenset().union(*sets)
+
+
+def rs_swap(a, b):
+    """
+    Build a dictionary to swap RandomSymbols based on their underlying symbol.
+
+    i.e.
+    if    ``X = ('x', pspace1)``
+    and   ``Y = ('x', pspace2)``
+    then ``X`` and ``Y`` match and the key, value pair
+    ``{X:Y}`` will appear in the result
+
+    Inputs: collections a and b of random variables which share common symbols
+    Output: dict mapping RVs in a to RVs in b
+    """
+    d = {}
+    for rsa in a:
+        d[rsa] = [rsb for rsb in b if rsa.symbol == rsb.symbol][0]
+    return d
+
+
+def given(expr, condition=None, **kwargs):
+    r""" Conditional Random Expression.
+
+    Explanation
+    ===========
+
+    From a random expression and a condition on that expression creates a new
+    probability space from the condition and returns the same expression on that
+    conditional probability space.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import given, density, Die
+    >>> X = Die('X', 6)
+    >>> Y = given(X, X > 3)
+    >>> density(Y).dict
+    {4: 1/3, 5: 1/3, 6: 1/3}
+
+    Following convention, if the condition is a random symbol then that symbol
+    is considered fixed.
+
+    >>> from sympy.stats import Normal
+    >>> from sympy import pprint
+    >>> from sympy.abc import z
+
+    >>> X = Normal('X', 0, 1)
+    >>> Y = Normal('Y', 0, 1)
+    >>> pprint(density(X + Y, Y)(z), use_unicode=False)
+                    2
+           -(-Y + z)
+           -----------
+      ___       2
+    \/ 2 *e
+    ------------------
+             ____
+         2*\/ pi
+    """
+
+    if not is_random(condition) or pspace_independent(expr, condition):
+        return expr
+
+    if isinstance(condition, RandomSymbol):
+        condition = Eq(condition, condition.symbol)
+
+    condsymbols = random_symbols(condition)
+    if (isinstance(condition, Eq) and len(condsymbols) == 1 and
+        not isinstance(pspace(expr).domain, ConditionalDomain)):
+        rv = tuple(condsymbols)[0]
+
+        results = solveset(condition, rv)
+        if isinstance(results, Intersection) and S.Reals in results.args:
+            results = list(results.args[1])
+
+        sums = 0
+        for res in results:
+            temp = expr.subs(rv, res)
+            if temp == True:
+                return True
+            if temp != False:
+                # XXX: This seems nonsensical but preserves existing behaviour
+                # after the change that Relational is no longer a subclass of
+                # Expr. Here expr is sometimes Relational and sometimes Expr
+                # but we are trying to add them with +=. This needs to be
+                # fixed somehow.
+                if sums == 0 and isinstance(expr, Relational):
+                    sums = expr.subs(rv, res)
+                else:
+                    sums += expr.subs(rv, res)
+        if sums == 0:
+            return False
+        return sums
+
+    # Get full probability space of both the expression and the condition
+    fullspace = pspace(Tuple(expr, condition))
+    # Build new space given the condition
+    space = fullspace.conditional_space(condition, **kwargs)
+    # Dictionary to swap out RandomSymbols in expr with new RandomSymbols
+    # That point to the new conditional space
+    swapdict = rs_swap(fullspace.values, space.values)
+    # Swap random variables in the expression
+    expr = expr.xreplace(swapdict)
+    return expr
+
+
+def expectation(expr, condition=None, numsamples=None, evaluate=True, **kwargs):
+    """
+    Returns the expected value of a random expression.
+
+    Parameters
+    ==========
+
+    expr : Expr containing RandomSymbols
+        The expression of which you want to compute the expectation value
+    given : Expr containing RandomSymbols
+        A conditional expression. E(X, X>0) is expectation of X given X > 0
+    numsamples : int
+        Enables sampling and approximates the expectation with this many samples
+    evalf : Bool (defaults to True)
+        If sampling return a number rather than a complex expression
+    evaluate : Bool (defaults to True)
+        In case of continuous systems return unevaluated integral
+
+    Examples
+    ========
+
+    >>> from sympy.stats import E, Die
+    >>> X = Die('X', 6)
+    >>> E(X)
+    7/2
+    >>> E(2*X + 1)
+    8
+
+    >>> E(X, X > 3) # Expectation of X given that it is above 3
+    5
+    """
+
+    if not is_random(expr):  # expr isn't random?
+        return expr
+    kwargs['numsamples'] = numsamples
+    from sympy.stats.symbolic_probability import Expectation
+    if evaluate:
+        return Expectation(expr, condition).doit(**kwargs)
+    return Expectation(expr, condition)
+
+
+def probability(condition, given_condition=None, numsamples=None,
+                evaluate=True, **kwargs):
+    """
+    Probability that a condition is true, optionally given a second condition.
+
+    Parameters
+    ==========
+
+    condition : Combination of Relationals containing RandomSymbols
+        The condition of which you want to compute the probability
+    given_condition : Combination of Relationals containing RandomSymbols
+        A conditional expression. P(X > 1, X > 0) is expectation of X > 1
+        given X > 0
+    numsamples : int
+        Enables sampling and approximates the probability with this many samples
+    evaluate : Bool (defaults to True)
+        In case of continuous systems return unevaluated integral
+
+    Examples
+    ========
+
+    >>> from sympy.stats import P, Die
+    >>> from sympy import Eq
+    >>> X, Y = Die('X', 6), Die('Y', 6)
+    >>> P(X > 3)
+    1/2
+    >>> P(Eq(X, 5), X > 2) # Probability that X == 5 given that X > 2
+    1/4
+    >>> P(X > Y)
+    5/12
+    """
+
+    kwargs['numsamples'] = numsamples
+    from sympy.stats.symbolic_probability import Probability
+    if evaluate:
+        return Probability(condition, given_condition).doit(**kwargs)
+    return Probability(condition, given_condition)
+
+
+class Density(Basic):
+    expr = property(lambda self: self.args[0])
+
+    def __new__(cls, expr, condition = None):
+        expr = _sympify(expr)
+        if condition is None:
+            obj = Basic.__new__(cls, expr)
+        else:
+            condition = _sympify(condition)
+            obj = Basic.__new__(cls, expr, condition)
+        return obj
+
+    @property
+    def condition(self):
+        if len(self.args) > 1:
+            return self.args[1]
+        else:
+            return None
+
+    def doit(self, evaluate=True, **kwargs):
+        from sympy.stats.random_matrix import RandomMatrixPSpace
+        from sympy.stats.joint_rv import JointPSpace
+        from sympy.stats.matrix_distributions import MatrixPSpace
+        from sympy.stats.compound_rv import CompoundPSpace
+        from sympy.stats.frv import SingleFiniteDistribution
+        expr, condition = self.expr, self.condition
+
+        if isinstance(expr, SingleFiniteDistribution):
+            return expr.dict
+        if condition is not None:
+            # Recompute on new conditional expr
+            expr = given(expr, condition, **kwargs)
+        if not random_symbols(expr):
+            return Lambda(x, DiracDelta(x - expr))
+        if isinstance(expr, RandomSymbol):
+            if isinstance(expr.pspace, (SinglePSpace, JointPSpace, MatrixPSpace)) and \
+                hasattr(expr.pspace, 'distribution'):
+                return expr.pspace.distribution
+            elif isinstance(expr.pspace, RandomMatrixPSpace):
+                return expr.pspace.model
+        if isinstance(pspace(expr), CompoundPSpace):
+            kwargs['compound_evaluate'] = evaluate
+        result = pspace(expr).compute_density(expr, **kwargs)
+
+        if evaluate and hasattr(result, 'doit'):
+            return result.doit()
+        else:
+            return result
+
+
+def density(expr, condition=None, evaluate=True, numsamples=None, **kwargs):
+    """
+    Probability density of a random expression, optionally given a second
+    condition.
+
+    Explanation
+    ===========
+
+    This density will take on different forms for different types of
+    probability spaces. Discrete variables produce Dicts. Continuous
+    variables produce Lambdas.
+
+    Parameters
+    ==========
+
+    expr : Expr containing RandomSymbols
+        The expression of which you want to compute the density value
+    condition : Relational containing RandomSymbols
+        A conditional expression. density(X > 1, X > 0) is density of X > 1
+        given X > 0
+    numsamples : int
+        Enables sampling and approximates the density with this many samples
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, Die, Normal
+    >>> from sympy import Symbol
+
+    >>> x = Symbol('x')
+    >>> D = Die('D', 6)
+    >>> X = Normal(x, 0, 1)
+
+    >>> density(D).dict
+    {1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
+    >>> density(2*D).dict
+    {2: 1/6, 4: 1/6, 6: 1/6, 8: 1/6, 10: 1/6, 12: 1/6}
+    >>> density(X)(x)
+    sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))
+    """
+
+    if numsamples:
+        return sampling_density(expr, condition, numsamples=numsamples,
+                **kwargs)
+
+    return Density(expr, condition).doit(evaluate=evaluate, **kwargs)
+
+
+def cdf(expr, condition=None, evaluate=True, **kwargs):
+    """
+    Cumulative Distribution Function of a random expression.
+
+    optionally given a second condition.
+
+    Explanation
+    ===========
+
+    This density will take on different forms for different types of
+    probability spaces.
+    Discrete variables produce Dicts.
+    Continuous variables produce Lambdas.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, Die, Normal, cdf
+
+    >>> D = Die('D', 6)
+    >>> X = Normal('X', 0, 1)
+
+    >>> density(D).dict
+    {1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
+    >>> cdf(D)
+    {1: 1/6, 2: 1/3, 3: 1/2, 4: 2/3, 5: 5/6, 6: 1}
+    >>> cdf(3*D, D > 2)
+    {9: 1/4, 12: 1/2, 15: 3/4, 18: 1}
+
+    >>> cdf(X)
+    Lambda(_z, erf(sqrt(2)*_z/2)/2 + 1/2)
+    """
+    if condition is not None:  # If there is a condition
+        # Recompute on new conditional expr
+        return cdf(given(expr, condition, **kwargs), **kwargs)
+
+    # Otherwise pass work off to the ProbabilitySpace
+    result = pspace(expr).compute_cdf(expr, **kwargs)
+
+    if evaluate and hasattr(result, 'doit'):
+        return result.doit()
+    else:
+        return result
+
+
+def characteristic_function(expr, condition=None, evaluate=True, **kwargs):
+    """
+    Characteristic function of a random expression, optionally given a second condition.
+
+    Returns a Lambda.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, DiscreteUniform, Poisson, characteristic_function
+
+    >>> X = Normal('X', 0, 1)
+    >>> characteristic_function(X)
+    Lambda(_t, exp(-_t**2/2))
+
+    >>> Y = DiscreteUniform('Y', [1, 2, 7])
+    >>> characteristic_function(Y)
+    Lambda(_t, exp(7*_t*I)/3 + exp(2*_t*I)/3 + exp(_t*I)/3)
+
+    >>> Z = Poisson('Z', 2)
+    >>> characteristic_function(Z)
+    Lambda(_t, exp(2*exp(_t*I) - 2))
+    """
+    if condition is not None:
+        return characteristic_function(given(expr, condition, **kwargs), **kwargs)
+
+    result = pspace(expr).compute_characteristic_function(expr, **kwargs)
+
+    if evaluate and hasattr(result, 'doit'):
+        return result.doit()
+    else:
+        return result
+
+def moment_generating_function(expr, condition=None, evaluate=True, **kwargs):
+    if condition is not None:
+        return moment_generating_function(given(expr, condition, **kwargs), **kwargs)
+
+    result = pspace(expr).compute_moment_generating_function(expr, **kwargs)
+
+    if evaluate and hasattr(result, 'doit'):
+        return result.doit()
+    else:
+        return result
+
+def where(condition, given_condition=None, **kwargs):
+    """
+    Returns the domain where a condition is True.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import where, Die, Normal
+    >>> from sympy import And
+
+    >>> D1, D2 = Die('a', 6), Die('b', 6)
+    >>> a, b = D1.symbol, D2.symbol
+    >>> X = Normal('x', 0, 1)
+
+    >>> where(X**2<1)
+    Domain: (-1 < x) & (x < 1)
+
+    >>> where(X**2<1).set
+    Interval.open(-1, 1)
+
+    >>> where(And(D1<=D2, D2<3))
+    Domain: (Eq(a, 1) & Eq(b, 1)) | (Eq(a, 1) & Eq(b, 2)) | (Eq(a, 2) & Eq(b, 2))
+    """
+    if given_condition is not None:  # If there is a condition
+        # Recompute on new conditional expr
+        return where(given(condition, given_condition, **kwargs), **kwargs)
+
+    # Otherwise pass work off to the ProbabilitySpace
+    return pspace(condition).where(condition, **kwargs)
+
+
+@doctest_depends_on(modules=('scipy',))
+def sample(expr, condition=None, size=(), library='scipy',
+           numsamples=1, seed=None, **kwargs):
+    """
+    A realization of the random expression.
+
+    Parameters
+    ==========
+
+    expr : Expression of random variables
+        Expression from which sample is extracted
+    condition : Expr containing RandomSymbols
+        A conditional expression
+    size : int, tuple
+        Represents size of each sample in numsamples
+    library : str
+        - 'scipy' : Sample using scipy
+        - 'numpy' : Sample using numpy
+        - 'pymc'  : Sample using PyMC
+
+        Choose any of the available options to sample from as string,
+        by default is 'scipy'
+    numsamples : int
+        Number of samples, each with size as ``size``.
+
+        .. deprecated:: 1.9
+
+        The ``numsamples`` parameter is deprecated and is only provided for
+        compatibility with v1.8. Use a list comprehension or an additional
+        dimension in ``size`` instead. See
+        :ref:`deprecated-sympy-stats-numsamples` for details.
+
+    seed :
+        An object to be used as seed by the given external library for sampling `expr`.
+        Following is the list of possible types of object for the supported libraries,
+
+        - 'scipy': int, numpy.random.RandomState, numpy.random.Generator
+        - 'numpy': int, numpy.random.RandomState, numpy.random.Generator
+        - 'pymc': int
+
+        Optional, by default None, in which case seed settings
+        related to the given library will be used.
+        No modifications to environment's global seed settings
+        are done by this argument.
+
+    Returns
+    =======
+
+    sample: float/list/numpy.ndarray
+        one sample or a collection of samples of the random expression.
+
+        - sample(X) returns float/numpy.float64/numpy.int64 object.
+        - sample(X, size=int/tuple) returns numpy.ndarray object.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Die, sample, Normal, Geometric
+    >>> X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6) # Finite Random Variable
+    >>> die_roll = sample(X + Y + Z)
+    >>> die_roll # doctest: +SKIP
+    3
+    >>> N = Normal('N', 3, 4) # Continuous Random Variable
+    >>> samp = sample(N)
+    >>> samp in N.pspace.domain.set
+    True
+    >>> samp = sample(N, N>0)
+    >>> samp > 0
+    True
+    >>> samp_list = sample(N, size=4)
+    >>> [sam in N.pspace.domain.set for sam in samp_list]
+    [True, True, True, True]
+    >>> sample(N, size = (2,3)) # doctest: +SKIP
+    array([[5.42519758, 6.40207856, 4.94991743],
+       [1.85819627, 6.83403519, 1.9412172 ]])
+    >>> G = Geometric('G', 0.5) # Discrete Random Variable
+    >>> samp_list = sample(G, size=3)
+    >>> samp_list # doctest: +SKIP
+    [1, 3, 2]
+    >>> [sam in G.pspace.domain.set for sam in samp_list]
+    [True, True, True]
+    >>> MN = Normal("MN", [3, 4], [[2, 1], [1, 2]]) # Joint Random Variable
+    >>> samp_list = sample(MN, size=4)
+    >>> samp_list # doctest: +SKIP
+    [array([2.85768055, 3.38954165]),
+     array([4.11163337, 4.3176591 ]),
+     array([0.79115232, 1.63232916]),
+     array([4.01747268, 3.96716083])]
+    >>> [tuple(sam) in MN.pspace.domain.set for sam in samp_list]
+    [True, True, True, True]
+
+    .. versionchanged:: 1.7.0
+        sample used to return an iterator containing the samples instead of value.
+
+    .. versionchanged:: 1.9.0
+        sample returns values or array of values instead of an iterator and numsamples is deprecated.
+
+    """
+
+    iterator = sample_iter(expr, condition, size=size, library=library,
+                                                        numsamples=numsamples, seed=seed)
+
+    if numsamples != 1:
+        sympy_deprecation_warning(
+            f"""
+            The numsamples parameter to sympy.stats.sample() is deprecated.
+            Either use a list comprehension, like
+
+            [sample(...) for i in range({numsamples})]
+
+            or add a dimension to size, like
+
+            sample(..., size={(numsamples,) + size})
+            """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-sympy-stats-numsamples",
+        )
+        return [next(iterator) for i in range(numsamples)]
+
+    return next(iterator)
+
+
+def quantile(expr, evaluate=True, **kwargs):
+    r"""
+    Return the :math:`p^{th}` order quantile of a probability distribution.
+
+    Explanation
+    ===========
+
+    Quantile is defined as the value at which the probability of the random
+    variable is less than or equal to the given probability.
+
+    .. math::
+        Q(p) = \inf\{x \in (-\infty, \infty) : p \le F(x)\}
+
+    Examples
+    ========
+
+    >>> from sympy.stats import quantile, Die, Exponential
+    >>> from sympy import Symbol, pprint
+    >>> p = Symbol("p")
+
+    >>> l = Symbol("lambda", positive=True)
+    >>> X = Exponential("x", l)
+    >>> quantile(X)(p)
+    -log(1 - p)/lambda
+
+    >>> D = Die("d", 6)
+    >>> pprint(quantile(D)(p), use_unicode=False)
+    /nan  for Or(p > 1, p < 0)
+    |
+    | 1       for p <= 1/6
+    |
+    | 2       for p <= 1/3
+    |
+    < 3       for p <= 1/2
+    |
+    | 4       for p <= 2/3
+    |
+    | 5       for p <= 5/6
+    |
+    \ 6        for p <= 1
+
+    """
+    result = pspace(expr).compute_quantile(expr, **kwargs)
+
+    if evaluate and hasattr(result, 'doit'):
+        return result.doit()
+    else:
+        return result
+
+def sample_iter(expr, condition=None, size=(), library='scipy',
+                    numsamples=S.Infinity, seed=None, **kwargs):
+
+    """
+    Returns an iterator of realizations from the expression given a condition.
+
+    Parameters
+    ==========
+
+    expr: Expr
+        Random expression to be realized
+    condition: Expr, optional
+        A conditional expression
+    size : int, tuple
+        Represents size of each sample in numsamples
+    numsamples: integer, optional
+        Length of the iterator (defaults to infinity)
+    seed :
+        An object to be used as seed by the given external library for sampling `expr`.
+        Following is the list of possible types of object for the supported libraries,
+
+        - 'scipy': int, numpy.random.RandomState, numpy.random.Generator
+        - 'numpy': int, numpy.random.RandomState, numpy.random.Generator
+        - 'pymc': int
+
+        Optional, by default None, in which case seed settings
+        related to the given library will be used.
+        No modifications to environment's global seed settings
+        are done by this argument.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, sample_iter
+    >>> X = Normal('X', 0, 1)
+    >>> expr = X*X + 3
+    >>> iterator = sample_iter(expr, numsamples=3) # doctest: +SKIP
+    >>> list(iterator) # doctest: +SKIP
+    [12, 4, 7]
+
+    Returns
+    =======
+
+    sample_iter: iterator object
+        iterator object containing the sample/samples of given expr
+
+    See Also
+    ========
+
+    sample
+    sampling_P
+    sampling_E
+
+    """
+    from sympy.stats.joint_rv import JointRandomSymbol
+    if not import_module(library):
+        raise ValueError("Failed to import %s" % library)
+
+    if condition is not None:
+        ps = pspace(Tuple(expr, condition))
+    else:
+        ps = pspace(expr)
+
+    rvs = list(ps.values)
+    if isinstance(expr, JointRandomSymbol):
+        expr = expr.subs({expr: RandomSymbol(expr.symbol, expr.pspace)})
+    else:
+        sub = {}
+        for arg in expr.args:
+            if isinstance(arg, JointRandomSymbol):
+                sub[arg] = RandomSymbol(arg.symbol, arg.pspace)
+        expr = expr.subs(sub)
+
+    def fn_subs(*args):
+        return expr.subs({rv: arg for rv, arg in zip(rvs, args)})
+
+    def given_fn_subs(*args):
+        if condition is not None:
+            return condition.subs({rv: arg for rv, arg in zip(rvs, args)})
+        return False
+
+    if library in ('pymc', 'pymc3'):
+        # Currently unable to lambdify in pymc
+        # TODO : Remove when lambdify accepts 'pymc' as module
+        fn = lambdify(rvs, expr, **kwargs)
+    else:
+        fn = lambdify(rvs, expr, modules=library, **kwargs)
+
+
+    if condition is not None:
+        given_fn = lambdify(rvs, condition, **kwargs)
+
+    def return_generator_infinite():
+        count = 0
+        _size = (1,)+((size,) if isinstance(size, int) else size)
+        while count < numsamples:
+            d = ps.sample(size=_size, library=library, seed=seed)  # a dictionary that maps RVs to values
+            args = [d[rv][0] for rv in rvs]
+
+            if condition is not None:  # Check that these values satisfy the condition
+                # TODO: Replace the try-except block with only given_fn(*args)
+                # once lambdify works with unevaluated SymPy objects.
+                try:
+                    gd = given_fn(*args)
+                except (NameError, TypeError):
+                    gd = given_fn_subs(*args)
+                if gd != True and gd != False:
+                    raise ValueError(
+                        "Conditions must not contain free symbols")
+                if not gd:  # If the values don't satisfy then try again
+                    continue
+
+            yield fn(*args)
+            count += 1
+
+    def return_generator_finite():
+        faulty = True
+        while faulty:
+            d = ps.sample(size=(numsamples,) + ((size,) if isinstance(size, int) else size),
+                          library=library, seed=seed) # a dictionary that maps RVs to values
+
+            faulty = False
+            count = 0
+            while count < numsamples and not faulty:
+                args = [d[rv][count] for rv in rvs]
+                if condition is not None:  # Check that these values satisfy the condition
+                    # TODO: Replace the try-except block with only given_fn(*args)
+                    # once lambdify works with unevaluated SymPy objects.
+                    try:
+                        gd = given_fn(*args)
+                    except (NameError, TypeError):
+                        gd = given_fn_subs(*args)
+                    if gd != True and gd != False:
+                        raise ValueError(
+                            "Conditions must not contain free symbols")
+                    if not gd:  # If the values don't satisfy then try again
+                        faulty = True
+
+                count += 1
+
+        count = 0
+        while count < numsamples:
+            args = [d[rv][count] for rv in rvs]
+            # TODO: Replace the try-except block with only fn(*args)
+            # once lambdify works with unevaluated SymPy objects.
+            try:
+                yield fn(*args)
+            except (NameError, TypeError):
+                yield fn_subs(*args)
+            count += 1
+
+    if numsamples is S.Infinity:
+        return return_generator_infinite()
+
+    return return_generator_finite()
+
+def sample_iter_lambdify(expr, condition=None, size=(),
+                         numsamples=S.Infinity, seed=None, **kwargs):
+
+    return sample_iter(expr, condition=condition, size=size,
+                       numsamples=numsamples, seed=seed, **kwargs)
+
+def sample_iter_subs(expr, condition=None, size=(),
+                     numsamples=S.Infinity, seed=None, **kwargs):
+
+    return sample_iter(expr, condition=condition, size=size,
+                       numsamples=numsamples, seed=seed, **kwargs)
+
+
+def sampling_P(condition, given_condition=None, library='scipy', numsamples=1,
+               evalf=True, seed=None, **kwargs):
+    """
+    Sampling version of P.
+
+    See Also
+    ========
+
+    P
+    sampling_E
+    sampling_density
+
+    """
+
+    count_true = 0
+    count_false = 0
+    samples = sample_iter(condition, given_condition, library=library,
+                          numsamples=numsamples, seed=seed, **kwargs)
+
+    for sample in samples:
+        if sample:
+            count_true += 1
+        else:
+            count_false += 1
+
+    result = S(count_true) / numsamples
+    if evalf:
+        return result.evalf()
+    else:
+        return result
+
+
+def sampling_E(expr, given_condition=None, library='scipy', numsamples=1,
+               evalf=True, seed=None, **kwargs):
+    """
+    Sampling version of E.
+
+    See Also
+    ========
+
+    P
+    sampling_P
+    sampling_density
+    """
+    samples = list(sample_iter(expr, given_condition, library=library,
+                          numsamples=numsamples, seed=seed, **kwargs))
+    result = Add(*samples) / numsamples
+
+    if evalf:
+        return result.evalf()
+    else:
+        return result
+
+def sampling_density(expr, given_condition=None, library='scipy',
+                    numsamples=1, seed=None, **kwargs):
+    """
+    Sampling version of density.
+
+    See Also
+    ========
+    density
+    sampling_P
+    sampling_E
+    """
+
+    results = {}
+    for result in sample_iter(expr, given_condition, library=library,
+                              numsamples=numsamples, seed=seed, **kwargs):
+        results[result] = results.get(result, 0) + 1
+
+    return results
+
+
+def dependent(a, b):
+    """
+    Dependence of two random expressions.
+
+    Two expressions are independent if knowledge of one does not change
+    computations on the other.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, dependent, given
+    >>> from sympy import Tuple, Eq
+
+    >>> X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    >>> dependent(X, Y)
+    False
+    >>> dependent(2*X + Y, -Y)
+    True
+    >>> X, Y = given(Tuple(X, Y), Eq(X + Y, 3))
+    >>> dependent(X, Y)
+    True
+
+    See Also
+    ========
+
+    independent
+    """
+    if pspace_independent(a, b):
+        return False
+
+    z = Symbol('z', real=True)
+    # Dependent if density is unchanged when one is given information about
+    # the other
+    return (density(a, Eq(b, z)) != density(a) or
+            density(b, Eq(a, z)) != density(b))
+
+
+def independent(a, b):
+    """
+    Independence of two random expressions.
+
+    Two expressions are independent if knowledge of one does not change
+    computations on the other.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, independent, given
+    >>> from sympy import Tuple, Eq
+
+    >>> X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    >>> independent(X, Y)
+    True
+    >>> independent(2*X + Y, -Y)
+    False
+    >>> X, Y = given(Tuple(X, Y), Eq(X + Y, 3))
+    >>> independent(X, Y)
+    False
+
+    See Also
+    ========
+
+    dependent
+    """
+    return not dependent(a, b)
+
+
+def pspace_independent(a, b):
+    """
+    Tests for independence between a and b by checking if their PSpaces have
+    overlapping symbols. This is a sufficient but not necessary condition for
+    independence and is intended to be used internally.
+
+    Notes
+    =====
+
+    pspace_independent(a, b) implies independent(a, b)
+    independent(a, b) does not imply pspace_independent(a, b)
+    """
+    a_symbols = set(pspace(b).symbols)
+    b_symbols = set(pspace(a).symbols)
+
+    if len(set(random_symbols(a)).intersection(random_symbols(b))) != 0:
+        return False
+
+    if len(a_symbols.intersection(b_symbols)) == 0:
+        return True
+    return None
+
+
+def rv_subs(expr, symbols=None):
+    """
+    Given a random expression replace all random variables with their symbols.
+
+    If symbols keyword is given restrict the swap to only the symbols listed.
+    """
+    if symbols is None:
+        symbols = random_symbols(expr)
+    if not symbols:
+        return expr
+    swapdict = {rv: rv.symbol for rv in symbols}
+    return expr.subs(swapdict)
+
+
+class NamedArgsMixin:
+    _argnames: tuple[str, ...] = ()
+
+    def __getattr__(self, attr):
+        try:
+            return self.args[self._argnames.index(attr)]
+        except ValueError:
+            raise AttributeError("'%s' object has no attribute '%s'" % (
+                type(self).__name__, attr))
+
+
+class Distribution(Basic):
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """ A random realization from the distribution """
+
+        module = import_module(library)
+        if library in {'scipy', 'numpy', 'pymc3', 'pymc'} and module is None:
+            raise ValueError("Failed to import %s" % library)
+
+        if library == 'scipy':
+            # scipy does not require map as it can handle using custom distributions.
+            # However, we will still use a map where we can.
+
+            # TODO: do this for drv.py and frv.py if necessary.
+            # TODO: add more distributions here if there are more
+            # See links below referring to sections beginning with "A common parametrization..."
+            # I will remove all these comments if everything is ok.
+
+            from sympy.stats.sampling.sample_scipy import do_sample_scipy
+            import numpy
+            if seed is None or isinstance(seed, int):
+                rand_state = numpy.random.default_rng(seed=seed)
+            else:
+                rand_state = seed
+            samps = do_sample_scipy(self, size, rand_state)
+
+        elif library == 'numpy':
+            from sympy.stats.sampling.sample_numpy import do_sample_numpy
+            import numpy
+            if seed is None or isinstance(seed, int):
+                rand_state = numpy.random.default_rng(seed=seed)
+            else:
+                rand_state = seed
+            _size = None if size == () else size
+            samps = do_sample_numpy(self, _size, rand_state)
+        elif library in ('pymc', 'pymc3'):
+            from sympy.stats.sampling.sample_pymc import do_sample_pymc
+            import logging
+            logging.getLogger("pymc").setLevel(logging.ERROR)
+            try:
+                import pymc
+            except ImportError:
+                import pymc3 as pymc
+
+            with pymc.Model():
+                if do_sample_pymc(self):
+                    samps = pymc.sample(draws=prod(size), chains=1, compute_convergence_checks=False,
+                            progressbar=False, random_seed=seed, return_inferencedata=False)[:]['X']
+                    samps = samps.reshape(size)
+                else:
+                    samps = None
+
+        else:
+            raise NotImplementedError("Sampling from %s is not supported yet."
+                                      % str(library))
+
+        if samps is not None:
+            return samps
+        raise NotImplementedError(
+            "Sampling for %s is not currently implemented from %s"
+            % (self, library))
+
+
+def _value_check(condition, message):
+    """
+    Raise a ValueError with message if condition is False, else
+    return True if all conditions were True, else False.
+
+    Examples
+    ========
+
+    >>> from sympy.stats.rv import _value_check
+    >>> from sympy.abc import a, b, c
+    >>> from sympy import And, Dummy
+
+    >>> _value_check(2 < 3, '')
+    True
+
+    Here, the condition is not False, but it does not evaluate to True
+    so False is returned (but no error is raised). So checking if the
+    return value is True or False will tell you if all conditions were
+    evaluated.
+
+    >>> _value_check(a < b, '')
+    False
+
+    In this case the condition is False so an error is raised:
+
+    >>> r = Dummy(real=True)
+    >>> _value_check(r < r - 1, 'condition is not true')
+    Traceback (most recent call last):
+    ...
+    ValueError: condition is not true
+
+    If no condition of many conditions must be False, they can be
+    checked by passing them as an iterable:
+
+    >>> _value_check((a < 0, b < 0, c < 0), '')
+    False
+
+    The iterable can be a generator, too:
+
+    >>> _value_check((i < 0 for i in (a, b, c)), '')
+    False
+
+    The following are equivalent to the above but do not pass
+    an iterable:
+
+    >>> all(_value_check(i < 0, '') for i in (a, b, c))
+    False
+    >>> _value_check(And(a < 0, b < 0, c < 0), '')
+    False
+    """
+    if not iterable(condition):
+        condition = [condition]
+    truth = fuzzy_and(condition)
+    if truth == False:
+        raise ValueError(message)
+    return truth == True
+
+def _symbol_converter(sym):
+    """
+    Casts the parameter to Symbol if it is 'str'
+    otherwise no operation is performed on it.
+
+    Parameters
+    ==========
+
+    sym
+        The parameter to be converted.
+
+    Returns
+    =======
+
+    Symbol
+        the parameter converted to Symbol.
+
+    Raises
+    ======
+
+    TypeError
+        If the parameter is not an instance of both str and
+        Symbol.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.stats.rv import _symbol_converter
+    >>> s = _symbol_converter('s')
+    >>> isinstance(s, Symbol)
+    True
+    >>> _symbol_converter(1)
+    Traceback (most recent call last):
+    ...
+    TypeError: 1 is neither a Symbol nor a string
+    >>> r = Symbol('r')
+    >>> isinstance(r, Symbol)
+    True
+    """
+    if isinstance(sym, str):
+        sym = Symbol(sym)
+    if not isinstance(sym, Symbol):
+        raise TypeError("%s is neither a Symbol nor a string"%(sym))
+    return sym
+
+def sample_stochastic_process(process):
+    """
+    This function is used to sample from stochastic process.
+
+    Parameters
+    ==========
+
+    process: StochasticProcess
+        Process used to extract the samples. It must be an instance of
+        StochasticProcess
+
+    Examples
+    ========
+
+    >>> from sympy.stats import sample_stochastic_process, DiscreteMarkovChain
+    >>> from sympy import Matrix
+    >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]])
+    >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    >>> next(sample_stochastic_process(Y)) in Y.state_space
+    True
+    >>> next(sample_stochastic_process(Y))  # doctest: +SKIP
+    0
+    >>> next(sample_stochastic_process(Y)) # doctest: +SKIP
+    2
+
+    Returns
+    =======
+
+    sample: iterator object
+        iterator object containing the sample of given process
+
+    """
+    from sympy.stats.stochastic_process_types import StochasticProcess
+    if not isinstance(process, StochasticProcess):
+        raise ValueError("Process must be an instance of Stochastic Process")
+    return process.sample()

venv/lib/python3.10/site-packages/sympy/stats/rv_interface.py

@@ -0,0 +1,519 @@
+from sympy.sets import FiniteSet
+from sympy.core.numbers import Rational
+from sympy.core.relational import Eq
+from sympy.core.symbol import Dummy
+from sympy.functions.combinatorial.factorials import FallingFactorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import piecewise_fold
+from sympy.integrals.integrals import Integral
+from sympy.solvers.solveset import solveset
+from .rv import (probability, expectation, density, where, given, pspace, cdf, PSpace,
+                 characteristic_function, sample, sample_iter, random_symbols, independent, dependent,
+                 sampling_density, moment_generating_function, quantile, is_random,
+                 sample_stochastic_process)
+
+
+__all__ = ['P', 'E', 'H', 'density', 'where', 'given', 'sample', 'cdf',
+        'characteristic_function', 'pspace', 'sample_iter', 'variance', 'std',
+        'skewness', 'kurtosis', 'covariance', 'dependent', 'entropy', 'median',
+        'independent', 'random_symbols', 'correlation', 'factorial_moment',
+        'moment', 'cmoment', 'sampling_density', 'moment_generating_function',
+        'smoment', 'quantile', 'sample_stochastic_process']
+
+
+
+def moment(X, n, c=0, condition=None, *, evaluate=True, **kwargs):
+    """
+    Return the nth moment of a random expression about c.
+
+    .. math::
+        moment(X, c, n) = E((X-c)^{n})
+
+    Default value of c is 0.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Die, moment, E
+    >>> X = Die('X', 6)
+    >>> moment(X, 1, 6)
+    -5/2
+    >>> moment(X, 2)
+    91/6
+    >>> moment(X, 1) == E(X)
+    True
+    """
+    from sympy.stats.symbolic_probability import Moment
+    if evaluate:
+        return Moment(X, n, c, condition).doit()
+    return Moment(X, n, c, condition).rewrite(Integral)
+
+
+def variance(X, condition=None, **kwargs):
+    """
+    Variance of a random expression.
+
+    .. math::
+        variance(X) = E((X-E(X))^{2})
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Die, Bernoulli, variance
+    >>> from sympy import simplify, Symbol
+
+    >>> X = Die('X', 6)
+    >>> p = Symbol('p')
+    >>> B = Bernoulli('B', p, 1, 0)
+
+    >>> variance(2*X)
+    35/3
+
+    >>> simplify(variance(B))
+    p*(1 - p)
+    """
+    if is_random(X) and pspace(X) == PSpace():
+        from sympy.stats.symbolic_probability import Variance
+        return Variance(X, condition)
+
+    return cmoment(X, 2, condition, **kwargs)
+
+
+def standard_deviation(X, condition=None, **kwargs):
+    r"""
+    Standard Deviation of a random expression
+
+    .. math::
+        std(X) = \sqrt(E((X-E(X))^{2}))
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Bernoulli, std
+    >>> from sympy import Symbol, simplify
+
+    >>> p = Symbol('p')
+    >>> B = Bernoulli('B', p, 1, 0)
+
+    >>> simplify(std(B))
+    sqrt(p*(1 - p))
+    """
+    return sqrt(variance(X, condition, **kwargs))
+std = standard_deviation
+
+def entropy(expr, condition=None, **kwargs):
+    """
+    Calculuates entropy of a probability distribution.
+
+    Parameters
+    ==========
+
+    expression : the random expression whose entropy is to be calculated
+    condition : optional, to specify conditions on random expression
+    b: base of the logarithm, optional
+       By default, it is taken as Euler's number
+
+    Returns
+    =======
+
+    result : Entropy of the expression, a constant
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, Die, entropy
+    >>> X = Normal('X', 0, 1)
+    >>> entropy(X)
+    log(2)/2 + 1/2 + log(pi)/2
+
+    >>> D = Die('D', 4)
+    >>> entropy(D)
+    log(4)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Entropy_%28information_theory%29
+    .. [2] https://www.crmarsh.com/static/pdf/Charles_Marsh_Continuous_Entropy.pdf
+    .. [3] https://kconrad.math.uconn.edu/blurbs/analysis/entropypost.pdf
+    """
+    pdf = density(expr, condition, **kwargs)
+    base = kwargs.get('b', exp(1))
+    if isinstance(pdf, dict):
+            return sum([-prob*log(prob, base) for prob in pdf.values()])
+    return expectation(-log(pdf(expr), base))
+
+def covariance(X, Y, condition=None, **kwargs):
+    """
+    Covariance of two random expressions.
+
+    Explanation
+    ===========
+
+    The expectation that the two variables will rise and fall together
+
+    .. math::
+        covariance(X,Y) = E((X-E(X)) (Y-E(Y)))
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Exponential, covariance
+    >>> from sympy import Symbol
+
+    >>> rate = Symbol('lambda', positive=True, real=True)
+    >>> X = Exponential('X', rate)
+    >>> Y = Exponential('Y', rate)
+
+    >>> covariance(X, X)
+    lambda**(-2)
+    >>> covariance(X, Y)
+    0
+    >>> covariance(X, Y + rate*X)
+    1/lambda
+    """
+    if (is_random(X) and pspace(X) == PSpace()) or (is_random(Y) and pspace(Y) == PSpace()):
+        from sympy.stats.symbolic_probability import Covariance
+        return Covariance(X, Y, condition)
+
+    return expectation(
+        (X - expectation(X, condition, **kwargs)) *
+        (Y - expectation(Y, condition, **kwargs)),
+        condition, **kwargs)
+
+
+def correlation(X, Y, condition=None, **kwargs):
+    r"""
+    Correlation of two random expressions, also known as correlation
+    coefficient or Pearson's correlation.
+
+    Explanation
+    ===========
+
+    The normalized expectation that the two variables will rise
+    and fall together
+
+    .. math::
+        correlation(X,Y) = E((X-E(X))(Y-E(Y)) / (\sigma_x  \sigma_y))
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Exponential, correlation
+    >>> from sympy import Symbol
+
+    >>> rate = Symbol('lambda', positive=True, real=True)
+    >>> X = Exponential('X', rate)
+    >>> Y = Exponential('Y', rate)
+
+    >>> correlation(X, X)
+    1
+    >>> correlation(X, Y)
+    0
+    >>> correlation(X, Y + rate*X)
+    1/sqrt(1 + lambda**(-2))
+    """
+    return covariance(X, Y, condition, **kwargs)/(std(X, condition, **kwargs)
+     * std(Y, condition, **kwargs))
+
+
+def cmoment(X, n, condition=None, *, evaluate=True, **kwargs):
+    """
+    Return the nth central moment of a random expression about its mean.
+
+    .. math::
+        cmoment(X, n) = E((X - E(X))^{n})
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Die, cmoment, variance
+    >>> X = Die('X', 6)
+    >>> cmoment(X, 3)
+    0
+    >>> cmoment(X, 2)
+    35/12
+    >>> cmoment(X, 2) == variance(X)
+    True
+    """
+    from sympy.stats.symbolic_probability import CentralMoment
+    if evaluate:
+        return CentralMoment(X, n, condition).doit()
+    return CentralMoment(X, n, condition).rewrite(Integral)
+
+
+def smoment(X, n, condition=None, **kwargs):
+    r"""
+    Return the nth Standardized moment of a random expression.
+
+    .. math::
+        smoment(X, n) = E(((X - \mu)/\sigma_X)^{n})
+
+    Examples
+    ========
+
+    >>> from sympy.stats import skewness, Exponential, smoment
+    >>> from sympy import Symbol
+    >>> rate = Symbol('lambda', positive=True, real=True)
+    >>> Y = Exponential('Y', rate)
+    >>> smoment(Y, 4)
+    9
+    >>> smoment(Y, 4) == smoment(3*Y, 4)
+    True
+    >>> smoment(Y, 3) == skewness(Y)
+    True
+    """
+    sigma = std(X, condition, **kwargs)
+    return (1/sigma)**n*cmoment(X, n, condition, **kwargs)
+
+def skewness(X, condition=None, **kwargs):
+    r"""
+    Measure of the asymmetry of the probability distribution.
+
+    Explanation
+    ===========
+
+    Positive skew indicates that most of the values lie to the right of
+    the mean.
+
+    .. math::
+        skewness(X) = E(((X - E(X))/\sigma_X)^{3})
+
+    Parameters
+    ==========
+
+    condition : Expr containing RandomSymbols
+            A conditional expression. skewness(X, X>0) is skewness of X given X > 0
+
+    Examples
+    ========
+
+    >>> from sympy.stats import skewness, Exponential, Normal
+    >>> from sympy import Symbol
+    >>> X = Normal('X', 0, 1)
+    >>> skewness(X)
+    0
+    >>> skewness(X, X > 0) # find skewness given X > 0
+    (-sqrt(2)/sqrt(pi) + 4*sqrt(2)/pi**(3/2))/(1 - 2/pi)**(3/2)
+
+    >>> rate = Symbol('lambda', positive=True, real=True)
+    >>> Y = Exponential('Y', rate)
+    >>> skewness(Y)
+    2
+    """
+    return smoment(X, 3, condition=condition, **kwargs)
+
+def kurtosis(X, condition=None, **kwargs):
+    r"""
+    Characterizes the tails/outliers of a probability distribution.
+
+    Explanation
+    ===========
+
+    Kurtosis of any univariate normal distribution is 3. Kurtosis less than
+    3 means that the distribution produces fewer and less extreme outliers
+    than the normal distribution.
+
+    .. math::
+        kurtosis(X) = E(((X - E(X))/\sigma_X)^{4})
+
+    Parameters
+    ==========
+
+    condition : Expr containing RandomSymbols
+            A conditional expression. kurtosis(X, X>0) is kurtosis of X given X > 0
+
+    Examples
+    ========
+
+    >>> from sympy.stats import kurtosis, Exponential, Normal
+    >>> from sympy import Symbol
+    >>> X = Normal('X', 0, 1)
+    >>> kurtosis(X)
+    3
+    >>> kurtosis(X, X > 0) # find kurtosis given X > 0
+    (-4/pi - 12/pi**2 + 3)/(1 - 2/pi)**2
+
+    >>> rate = Symbol('lamda', positive=True, real=True)
+    >>> Y = Exponential('Y', rate)
+    >>> kurtosis(Y)
+    9
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Kurtosis
+    .. [2] https://mathworld.wolfram.com/Kurtosis.html
+    """
+    return smoment(X, 4, condition=condition, **kwargs)
+
+
+def factorial_moment(X, n, condition=None, **kwargs):
+    """
+    The factorial moment is a mathematical quantity defined as the expectation
+    or average of the falling factorial of a random variable.
+
+    .. math::
+        factorial-moment(X, n) = E(X(X - 1)(X - 2)...(X - n + 1))
+
+    Parameters
+    ==========
+
+    n: A natural number, n-th factorial moment.
+
+    condition : Expr containing RandomSymbols
+            A conditional expression.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import factorial_moment, Poisson, Binomial
+    >>> from sympy import Symbol, S
+    >>> lamda = Symbol('lamda')
+    >>> X = Poisson('X', lamda)
+    >>> factorial_moment(X, 2)
+    lamda**2
+    >>> Y = Binomial('Y', 2, S.Half)
+    >>> factorial_moment(Y, 2)
+    1/2
+    >>> factorial_moment(Y, 2, Y > 1) # find factorial moment for Y > 1
+    2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Factorial_moment
+    .. [2] https://mathworld.wolfram.com/FactorialMoment.html
+    """
+    return expectation(FallingFactorial(X, n), condition=condition, **kwargs)
+
+def median(X, evaluate=True, **kwargs):
+    r"""
+    Calculuates the median of the probability distribution.
+
+    Explanation
+    ===========
+
+    Mathematically, median of Probability distribution is defined as all those
+    values of `m` for which the following condition is satisfied
+
+    .. math::
+        P(X\leq m) \geq  \frac{1}{2} \text{ and} \text{ } P(X\geq m)\geq \frac{1}{2}
+
+    Parameters
+    ==========
+
+    X: The random expression whose median is to be calculated.
+
+    Returns
+    =======
+
+    The FiniteSet or an Interval which contains the median of the
+    random expression.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, Die, median
+    >>> N = Normal('N', 3, 1)
+    >>> median(N)
+    {3}
+    >>> D = Die('D')
+    >>> median(D)
+    {3, 4}
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Median#Probability_distributions
+
+    """
+    if not is_random(X):
+        return X
+
+    from sympy.stats.crv import ContinuousPSpace
+    from sympy.stats.drv import DiscretePSpace
+    from sympy.stats.frv import FinitePSpace
+
+    if isinstance(pspace(X), FinitePSpace):
+        cdf = pspace(X).compute_cdf(X)
+        result = []
+        for key, value in cdf.items():
+            if value>= Rational(1, 2) and (1 - value) + \
+            pspace(X).probability(Eq(X, key)) >= Rational(1, 2):
+                result.append(key)
+        return FiniteSet(*result)
+    if isinstance(pspace(X), (ContinuousPSpace, DiscretePSpace)):
+        cdf = pspace(X).compute_cdf(X)
+        x = Dummy('x')
+        result = solveset(piecewise_fold(cdf(x) - Rational(1, 2)), x, pspace(X).set)
+        return result
+    raise NotImplementedError("The median of %s is not implemented."%str(pspace(X)))
+
+
+def coskewness(X, Y, Z, condition=None, **kwargs):
+    r"""
+    Calculates the co-skewness of three random variables.
+
+    Explanation
+    ===========
+
+    Mathematically Coskewness is defined as
+
+    .. math::
+        coskewness(X,Y,Z)=\frac{E[(X-E[X]) * (Y-E[Y]) * (Z-E[Z])]} {\sigma_{X}\sigma_{Y}\sigma_{Z}}
+
+    Parameters
+    ==========
+
+    X : RandomSymbol
+            Random Variable used to calculate coskewness
+    Y : RandomSymbol
+            Random Variable used to calculate coskewness
+    Z : RandomSymbol
+            Random Variable used to calculate coskewness
+    condition : Expr containing RandomSymbols
+            A conditional expression
+
+    Examples
+    ========
+
+    >>> from sympy.stats import coskewness, Exponential, skewness
+    >>> from sympy import symbols
+    >>> p = symbols('p', positive=True)
+    >>> X = Exponential('X', p)
+    >>> Y = Exponential('Y', 2*p)
+    >>> coskewness(X, Y, Y)
+    0
+    >>> coskewness(X, Y + X, Y + 2*X)
+    16*sqrt(85)/85
+    >>> coskewness(X + 2*Y, Y + X, Y + 2*X, X > 3)
+    9*sqrt(170)/85
+    >>> coskewness(Y, Y, Y) == skewness(Y)
+    True
+    >>> coskewness(X, Y + p*X, Y + 2*p*X)
+    4/(sqrt(1 + 1/(4*p**2))*sqrt(4 + 1/(4*p**2)))
+
+    Returns
+    =======
+
+    coskewness : The coskewness of the three random variables
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Coskewness
+
+    """
+    num = expectation((X - expectation(X, condition, **kwargs)) \
+         * (Y - expectation(Y, condition, **kwargs)) \
+         * (Z - expectation(Z, condition, **kwargs)), condition, **kwargs)
+    den = std(X, condition, **kwargs) * std(Y, condition, **kwargs) \
+         * std(Z, condition, **kwargs)
+    return num/den
+
+
+P = probability
+E = expectation
+H = entropy