Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sympy/interactive/__init__.py

@@ -0,0 +1,8 @@
+"""Helper module for setting up interactive SymPy sessions. """
+
+from .printing import init_printing
+from .session import init_session
+from .traversal import interactive_traversal
+
+
+__all__ = ['init_printing', 'init_session', 'interactive_traversal']

llmeval-env/lib/python3.10/site-packages/sympy/interactive/printing.py

@@ -0,0 +1,562 @@
+"""Tools for setting up printing in interactive sessions. """
+
+from sympy.external.importtools import version_tuple
+from io import BytesIO
+
+from sympy.printing.latex import latex as default_latex
+from sympy.printing.preview import preview
+from sympy.utilities.misc import debug
+from sympy.printing.defaults import Printable
+
+
+def _init_python_printing(stringify_func, **settings):
+    """Setup printing in Python interactive session. """
+    import sys
+    import builtins
+
+    def _displayhook(arg):
+        """Python's pretty-printer display hook.
+
+           This function was adapted from:
+
+            https://www.python.org/dev/peps/pep-0217/
+
+        """
+        if arg is not None:
+            builtins._ = None
+            print(stringify_func(arg, **settings))
+            builtins._ = arg
+
+    sys.displayhook = _displayhook
+
+
+def _init_ipython_printing(ip, stringify_func, use_latex, euler, forecolor,
+                           backcolor, fontsize, latex_mode, print_builtin,
+                           latex_printer, scale, **settings):
+    """Setup printing in IPython interactive session. """
+    try:
+        from IPython.lib.latextools import latex_to_png
+    except ImportError:
+        pass
+
+    # Guess best font color if none was given based on the ip.colors string.
+    # From the IPython documentation:
+    #   It has four case-insensitive values: 'nocolor', 'neutral', 'linux',
+    #   'lightbg'. The default is neutral, which should be legible on either
+    #   dark or light terminal backgrounds. linux is optimised for dark
+    #   backgrounds and lightbg for light ones.
+    if forecolor is None:
+        color = ip.colors.lower()
+        if color == 'lightbg':
+            forecolor = 'Black'
+        elif color == 'linux':
+            forecolor = 'White'
+        else:
+            # No idea, go with gray.
+            forecolor = 'Gray'
+        debug("init_printing: Automatic foreground color:", forecolor)
+
+    if use_latex == "svg":
+        extra_preamble = "\n\\special{color %s}" % forecolor
+    else:
+        extra_preamble = ""
+
+    imagesize = 'tight'
+    offset = "0cm,0cm"
+    resolution = round(150*scale)
+    dvi = r"-T %s -D %d -bg %s -fg %s -O %s" % (
+        imagesize, resolution, backcolor, forecolor, offset)
+    dvioptions = dvi.split()
+
+    svg_scale = 150/72*scale
+    dvioptions_svg = ["--no-fonts", "--scale={}".format(svg_scale)]
+
+    debug("init_printing: DVIOPTIONS:", dvioptions)
+    debug("init_printing: DVIOPTIONS_SVG:", dvioptions_svg)
+
+    latex = latex_printer or default_latex
+
+    def _print_plain(arg, p, cycle):
+        """caller for pretty, for use in IPython 0.11"""
+        if _can_print(arg):
+            p.text(stringify_func(arg))
+        else:
+            p.text(IPython.lib.pretty.pretty(arg))
+
+    def _preview_wrapper(o):
+        exprbuffer = BytesIO()
+        try:
+            preview(o, output='png', viewer='BytesIO', euler=euler,
+                    outputbuffer=exprbuffer, extra_preamble=extra_preamble,
+                    dvioptions=dvioptions, fontsize=fontsize)
+        except Exception as e:
+            # IPython swallows exceptions
+            debug("png printing:", "_preview_wrapper exception raised:",
+                  repr(e))
+            raise
+        return exprbuffer.getvalue()
+
+    def _svg_wrapper(o):
+        exprbuffer = BytesIO()
+        try:
+            preview(o, output='svg', viewer='BytesIO', euler=euler,
+                    outputbuffer=exprbuffer, extra_preamble=extra_preamble,
+                    dvioptions=dvioptions_svg, fontsize=fontsize)
+        except Exception as e:
+            # IPython swallows exceptions
+            debug("svg printing:", "_preview_wrapper exception raised:",
+                  repr(e))
+            raise
+        return exprbuffer.getvalue().decode('utf-8')
+
+    def _matplotlib_wrapper(o):
+        # mathtext can't render some LaTeX commands. For example, it can't
+        # render any LaTeX environments such as array or matrix. So here we
+        # ensure that if mathtext fails to render, we return None.
+        try:
+            try:
+                return latex_to_png(o, color=forecolor, scale=scale)
+            except TypeError: #  Old IPython version without color and scale
+                return latex_to_png(o)
+        except ValueError as e:
+            debug('matplotlib exception caught:', repr(e))
+            return None
+
+
+    # Hook methods for builtin SymPy printers
+    printing_hooks = ('_latex', '_sympystr', '_pretty', '_sympyrepr')
+
+
+    def _can_print(o):
+        """Return True if type o can be printed with one of the SymPy printers.
+
+        If o is a container type, this is True if and only if every element of
+        o can be printed in this way.
+        """
+
+        try:
+            # If you're adding another type, make sure you add it to printable_types
+            # later in this file as well
+
+            builtin_types = (list, tuple, set, frozenset)
+            if isinstance(o, builtin_types):
+                # If the object is a custom subclass with a custom str or
+                # repr, use that instead.
+                if (type(o).__str__ not in (i.__str__ for i in builtin_types) or
+                    type(o).__repr__ not in (i.__repr__ for i in builtin_types)):
+                    return False
+                return all(_can_print(i) for i in o)
+            elif isinstance(o, dict):
+                return all(_can_print(i) and _can_print(o[i]) for i in o)
+            elif isinstance(o, bool):
+                return False
+            elif isinstance(o, Printable):
+                # types known to SymPy
+                return True
+            elif any(hasattr(o, hook) for hook in printing_hooks):
+                # types which add support themselves
+                return True
+            elif isinstance(o, (float, int)) and print_builtin:
+                return True
+            return False
+        except RuntimeError:
+            return False
+            # This is in case maximum recursion depth is reached.
+            # Since RecursionError is for versions of Python 3.5+
+            # so this is to guard against RecursionError for older versions.
+
+    def _print_latex_png(o):
+        """
+        A function that returns a png rendered by an external latex
+        distribution, falling back to matplotlib rendering
+        """
+        if _can_print(o):
+            s = latex(o, mode=latex_mode, **settings)
+            if latex_mode == 'plain':
+                s = '$\\displaystyle %s$' % s
+            try:
+                return _preview_wrapper(s)
+            except RuntimeError as e:
+                debug('preview failed with:', repr(e),
+                      ' Falling back to matplotlib backend')
+                if latex_mode != 'inline':
+                    s = latex(o, mode='inline', **settings)
+                return _matplotlib_wrapper(s)
+
+    def _print_latex_svg(o):
+        """
+        A function that returns a svg rendered by an external latex
+        distribution, no fallback available.
+        """
+        if _can_print(o):
+            s = latex(o, mode=latex_mode, **settings)
+            if latex_mode == 'plain':
+                s = '$\\displaystyle %s$' % s
+            try:
+                return _svg_wrapper(s)
+            except RuntimeError as e:
+                debug('preview failed with:', repr(e),
+                      ' No fallback available.')
+
+    def _print_latex_matplotlib(o):
+        """
+        A function that returns a png rendered by mathtext
+        """
+        if _can_print(o):
+            s = latex(o, mode='inline', **settings)
+            return _matplotlib_wrapper(s)
+
+    def _print_latex_text(o):
+        """
+        A function to generate the latex representation of SymPy expressions.
+        """
+        if _can_print(o):
+            s = latex(o, mode=latex_mode, **settings)
+            if latex_mode == 'plain':
+                return '$\\displaystyle %s$' % s
+            return s
+
+    def _result_display(self, arg):
+        """IPython's pretty-printer display hook, for use in IPython 0.10
+
+           This function was adapted from:
+
+            ipython/IPython/hooks.py:155
+
+        """
+        if self.rc.pprint:
+            out = stringify_func(arg)
+
+            if '\n' in out:
+                print()
+
+            print(out)
+        else:
+            print(repr(arg))
+
+    import IPython
+    if version_tuple(IPython.__version__) >= version_tuple('0.11'):
+
+        # Printable is our own type, so we handle it with methods instead of
+        # the approach required by builtin types. This allows downstream
+        # packages to override the methods in their own subclasses of Printable,
+        # which avoids the effects of gh-16002.
+        printable_types = [float, tuple, list, set, frozenset, dict, int]
+
+        plaintext_formatter = ip.display_formatter.formatters['text/plain']
+
+        # Exception to the rule above: IPython has better dispatching rules
+        # for plaintext printing (xref ipython/ipython#8938), and we can't
+        # use `_repr_pretty_` without hitting a recursion error in _print_plain.
+        for cls in printable_types + [Printable]:
+            plaintext_formatter.for_type(cls, _print_plain)
+
+        svg_formatter = ip.display_formatter.formatters['image/svg+xml']
+        if use_latex in ('svg', ):
+            debug("init_printing: using svg formatter")
+            for cls in printable_types:
+                svg_formatter.for_type(cls, _print_latex_svg)
+            Printable._repr_svg_ = _print_latex_svg
+        else:
+            debug("init_printing: not using any svg formatter")
+            for cls in printable_types:
+                # Better way to set this, but currently does not work in IPython
+                #png_formatter.for_type(cls, None)
+                if cls in svg_formatter.type_printers:
+                    svg_formatter.type_printers.pop(cls)
+            Printable._repr_svg_ = Printable._repr_disabled
+
+        png_formatter = ip.display_formatter.formatters['image/png']
+        if use_latex in (True, 'png'):
+            debug("init_printing: using png formatter")
+            for cls in printable_types:
+                png_formatter.for_type(cls, _print_latex_png)
+            Printable._repr_png_ = _print_latex_png
+        elif use_latex == 'matplotlib':
+            debug("init_printing: using matplotlib formatter")
+            for cls in printable_types:
+                png_formatter.for_type(cls, _print_latex_matplotlib)
+            Printable._repr_png_ = _print_latex_matplotlib
+        else:
+            debug("init_printing: not using any png formatter")
+            for cls in printable_types:
+                # Better way to set this, but currently does not work in IPython
+                #png_formatter.for_type(cls, None)
+                if cls in png_formatter.type_printers:
+                    png_formatter.type_printers.pop(cls)
+            Printable._repr_png_ = Printable._repr_disabled
+
+        latex_formatter = ip.display_formatter.formatters['text/latex']
+        if use_latex in (True, 'mathjax'):
+            debug("init_printing: using mathjax formatter")
+            for cls in printable_types:
+                latex_formatter.for_type(cls, _print_latex_text)
+            Printable._repr_latex_ = _print_latex_text
+        else:
+            debug("init_printing: not using text/latex formatter")
+            for cls in printable_types:
+                # Better way to set this, but currently does not work in IPython
+                #latex_formatter.for_type(cls, None)
+                if cls in latex_formatter.type_printers:
+                    latex_formatter.type_printers.pop(cls)
+            Printable._repr_latex_ = Printable._repr_disabled
+
+    else:
+        ip.set_hook('result_display', _result_display)
+
+def _is_ipython(shell):
+    """Is a shell instance an IPython shell?"""
+    # shortcut, so we don't import IPython if we don't have to
+    from sys import modules
+    if 'IPython' not in modules:
+        return False
+    try:
+        from IPython.core.interactiveshell import InteractiveShell
+    except ImportError:
+        # IPython < 0.11
+        try:
+            from IPython.iplib import InteractiveShell
+        except ImportError:
+            # Reaching this points means IPython has changed in a backward-incompatible way
+            # that we don't know about. Warn?
+            return False
+    return isinstance(shell, InteractiveShell)
+
+# Used by the doctester to override the default for no_global
+NO_GLOBAL = False
+
+def init_printing(pretty_print=True, order=None, use_unicode=None,
+                  use_latex=None, wrap_line=None, num_columns=None,
+                  no_global=False, ip=None, euler=False, forecolor=None,
+                  backcolor='Transparent', fontsize='10pt',
+                  latex_mode='plain', print_builtin=True,
+                  str_printer=None, pretty_printer=None,
+                  latex_printer=None, scale=1.0, **settings):
+    r"""
+    Initializes pretty-printer depending on the environment.
+
+    Parameters
+    ==========
+
+    pretty_print : bool, default=True
+        If ``True``, use :func:`~.pretty_print` to stringify or the provided pretty
+        printer; if ``False``, use :func:`~.sstrrepr` to stringify or the provided string
+        printer.
+    order : string or None, default='lex'
+        There are a few different settings for this parameter:
+        ``'lex'`` (default), which is lexographic order;
+        ``'grlex'``, which is graded lexographic order;
+        ``'grevlex'``, which is reversed graded lexographic order;
+        ``'old'``, which is used for compatibility reasons and for long expressions;
+        ``None``, which sets it to lex.
+    use_unicode : bool or None, default=None
+        If ``True``, use unicode characters;
+        if ``False``, do not use unicode characters;
+        if ``None``, make a guess based on the environment.
+    use_latex : string, bool, or None, default=None
+        If ``True``, use default LaTeX rendering in GUI interfaces (png and
+        mathjax);
+        if ``False``, do not use LaTeX rendering;
+        if ``None``, make a guess based on the environment;
+        if ``'png'``, enable LaTeX rendering with an external LaTeX compiler,
+        falling back to matplotlib if external compilation fails;
+        if ``'matplotlib'``, enable LaTeX rendering with matplotlib;
+        if ``'mathjax'``, enable LaTeX text generation, for example MathJax
+        rendering in IPython notebook or text rendering in LaTeX documents;
+        if ``'svg'``, enable LaTeX rendering with an external latex compiler,
+        no fallback
+    wrap_line : bool
+        If True, lines will wrap at the end; if False, they will not wrap
+        but continue as one line. This is only relevant if ``pretty_print`` is
+        True.
+    num_columns : int or None, default=None
+        If ``int``, number of columns before wrapping is set to num_columns; if
+        ``None``, number of columns before wrapping is set to terminal width.
+        This is only relevant if ``pretty_print`` is ``True``.
+    no_global : bool, default=False
+        If ``True``, the settings become system wide;
+        if ``False``, use just for this console/session.
+    ip : An interactive console
+        This can either be an instance of IPython,
+        or a class that derives from code.InteractiveConsole.
+    euler : bool, optional, default=False
+        Loads the euler package in the LaTeX preamble for handwritten style
+        fonts (https://www.ctan.org/pkg/euler).
+    forecolor : string or None, optional, default=None
+        DVI setting for foreground color. ``None`` means that either ``'Black'``,
+        ``'White'``, or ``'Gray'`` will be selected based on a guess of the IPython
+        terminal color setting. See notes.
+    backcolor : string, optional, default='Transparent'
+        DVI setting for background color. See notes.
+    fontsize : string or int, optional, default='10pt'
+        A font size to pass to the LaTeX documentclass function in the
+        preamble. Note that the options are limited by the documentclass.
+        Consider using scale instead.
+    latex_mode : string, optional, default='plain'
+        The mode used in the LaTeX printer. Can be one of:
+        ``{'inline'|'plain'|'equation'|'equation*'}``.
+    print_builtin : boolean, optional, default=True
+        If ``True`` then floats and integers will be printed. If ``False`` the
+        printer will only print SymPy types.
+    str_printer : function, optional, default=None
+        A custom string printer function. This should mimic
+        :func:`~.sstrrepr()`.
+    pretty_printer : function, optional, default=None
+        A custom pretty printer. This should mimic :func:`~.pretty()`.
+    latex_printer : function, optional, default=None
+        A custom LaTeX printer. This should mimic :func:`~.latex()`.
+    scale : float, optional, default=1.0
+        Scale the LaTeX output when using the ``'png'`` or ``'svg'`` backends.
+        Useful for high dpi screens.
+    settings :
+        Any additional settings for the ``latex`` and ``pretty`` commands can
+        be used to fine-tune the output.
+
+    Examples
+    ========
+
+    >>> from sympy.interactive import init_printing
+    >>> from sympy import Symbol, sqrt
+    >>> from sympy.abc import x, y
+    >>> sqrt(5)
+    sqrt(5)
+    >>> init_printing(pretty_print=True) # doctest: +SKIP
+    >>> sqrt(5) # doctest: +SKIP
+      ___
+    \/ 5
+    >>> theta = Symbol('theta') # doctest: +SKIP
+    >>> init_printing(use_unicode=True) # doctest: +SKIP
+    >>> theta # doctest: +SKIP
+    \u03b8
+    >>> init_printing(use_unicode=False) # doctest: +SKIP
+    >>> theta # doctest: +SKIP
+    theta
+    >>> init_printing(order='lex') # doctest: +SKIP
+    >>> str(y + x + y**2 + x**2) # doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_printing(order='grlex') # doctest: +SKIP
+    >>> str(y + x + y**2 + x**2) # doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_printing(order='grevlex') # doctest: +SKIP
+    >>> str(y * x**2 + x * y**2) # doctest: +SKIP
+    x**2*y + x*y**2
+    >>> init_printing(order='old') # doctest: +SKIP
+    >>> str(x**2 + y**2 + x + y) # doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_printing(num_columns=10) # doctest: +SKIP
+    >>> x**2 + x + y**2 + y # doctest: +SKIP
+    x + y +
+    x**2 + y**2
+
+    Notes
+    =====
+
+    The foreground and background colors can be selected when using ``'png'`` or
+    ``'svg'`` LaTeX rendering. Note that before the ``init_printing`` command is
+    executed, the LaTeX rendering is handled by the IPython console and not SymPy.
+
+    The colors can be selected among the 68 standard colors known to ``dvips``,
+    for a list see [1]_. In addition, the background color can be
+    set to  ``'Transparent'`` (which is the default value).
+
+    When using the ``'Auto'`` foreground color, the guess is based on the
+    ``colors`` variable in the IPython console, see [2]_. Hence, if
+    that variable is set correctly in your IPython console, there is a high
+    chance that the output will be readable, although manual settings may be
+    needed.
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikibooks.org/wiki/LaTeX/Colors#The_68_standard_colors_known_to_dvips
+
+    .. [2] https://ipython.readthedocs.io/en/stable/config/details.html#terminal-colors
+
+    See Also
+    ========
+
+    sympy.printing.latex
+    sympy.printing.pretty
+
+    """
+    import sys
+    from sympy.printing.printer import Printer
+
+    if pretty_print:
+        if pretty_printer is not None:
+            stringify_func = pretty_printer
+        else:
+            from sympy.printing import pretty as stringify_func
+    else:
+        if str_printer is not None:
+            stringify_func = str_printer
+        else:
+            from sympy.printing import sstrrepr as stringify_func
+
+    # Even if ip is not passed, double check that not in IPython shell
+    in_ipython = False
+    if ip is None:
+        try:
+            ip = get_ipython()
+        except NameError:
+            pass
+        else:
+            in_ipython = (ip is not None)
+
+    if ip and not in_ipython:
+        in_ipython = _is_ipython(ip)
+
+    if in_ipython and pretty_print:
+        try:
+            import IPython
+            # IPython 1.0 deprecates the frontend module, so we import directly
+            # from the terminal module to prevent a deprecation message from being
+            # shown.
+            if version_tuple(IPython.__version__) >= version_tuple('1.0'):
+                from IPython.terminal.interactiveshell import TerminalInteractiveShell
+            else:
+                from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
+            from code import InteractiveConsole
+        except ImportError:
+            pass
+        else:
+            # This will be True if we are in the qtconsole or notebook
+            if not isinstance(ip, (InteractiveConsole, TerminalInteractiveShell)) \
+                    and 'ipython-console' not in ''.join(sys.argv):
+                if use_unicode is None:
+                    debug("init_printing: Setting use_unicode to True")
+                    use_unicode = True
+                if use_latex is None:
+                    debug("init_printing: Setting use_latex to True")
+                    use_latex = True
+
+    if not NO_GLOBAL and not no_global:
+        Printer.set_global_settings(order=order, use_unicode=use_unicode,
+                                    wrap_line=wrap_line, num_columns=num_columns)
+    else:
+        _stringify_func = stringify_func
+
+        if pretty_print:
+            stringify_func = lambda expr, **settings: \
+                             _stringify_func(expr, order=order,
+                                             use_unicode=use_unicode,
+                                             wrap_line=wrap_line,
+                                             num_columns=num_columns,
+                                             **settings)
+        else:
+            stringify_func = \
+                lambda expr, **settings: _stringify_func(
+                    expr, order=order, **settings)
+
+    if in_ipython:
+        mode_in_settings = settings.pop("mode", None)
+        if mode_in_settings:
+            debug("init_printing: Mode is not able to be set due to internals"
+                  "of IPython printing")
+        _init_ipython_printing(ip, stringify_func, use_latex, euler,
+                               forecolor, backcolor, fontsize, latex_mode,
+                               print_builtin, latex_printer, scale,
+                               **settings)
+    else:
+        _init_python_printing(stringify_func, **settings)

llmeval-env/lib/python3.10/site-packages/sympy/interactive/session.py

@@ -0,0 +1,463 @@
+"""Tools for setting up interactive sessions. """
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.external.importtools import version_tuple
+
+from sympy.interactive.printing import init_printing
+
+from sympy.utilities.misc import ARCH
+
+preexec_source = """\
+from sympy import *
+x, y, z, t = symbols('x y z t')
+k, m, n = symbols('k m n', integer=True)
+f, g, h = symbols('f g h', cls=Function)
+init_printing()
+"""
+
+verbose_message = """\
+These commands were executed:
+%(source)s
+Documentation can be found at https://docs.sympy.org/%(version)s
+"""
+
+no_ipython = """\
+Could not locate IPython. Having IPython installed is greatly recommended.
+See http://ipython.scipy.org for more details. If you use Debian/Ubuntu,
+just install the 'ipython' package and start isympy again.
+"""
+
+
+def _make_message(ipython=True, quiet=False, source=None):
+    """Create a banner for an interactive session. """
+    from sympy import __version__ as sympy_version
+    from sympy import SYMPY_DEBUG
+
+    import sys
+    import os
+
+    if quiet:
+        return ""
+
+    python_version = "%d.%d.%d" % sys.version_info[:3]
+
+    if ipython:
+        shell_name = "IPython"
+    else:
+        shell_name = "Python"
+
+    info = ['ground types: %s' % GROUND_TYPES]
+
+    cache = os.getenv('SYMPY_USE_CACHE')
+
+    if cache is not None and cache.lower() == 'no':
+        info.append('cache: off')
+
+    if SYMPY_DEBUG:
+        info.append('debugging: on')
+
+    args = shell_name, sympy_version, python_version, ARCH, ', '.join(info)
+    message = "%s console for SymPy %s (Python %s-%s) (%s)\n" % args
+
+    if source is None:
+        source = preexec_source
+
+    _source = ""
+
+    for line in source.split('\n')[:-1]:
+        if not line:
+            _source += '\n'
+        else:
+            _source += '>>> ' + line + '\n'
+
+    doc_version = sympy_version
+    if 'dev' in doc_version:
+        doc_version = "dev"
+    else:
+        doc_version = "%s/" % doc_version
+
+    message += '\n' + verbose_message % {'source': _source,
+                                         'version': doc_version}
+
+    return message
+
+
+def int_to_Integer(s):
+    """
+    Wrap integer literals with Integer.
+
+    This is based on the decistmt example from
+    https://docs.python.org/3/library/tokenize.html.
+
+    Only integer literals are converted.  Float literals are left alone.
+
+    Examples
+    ========
+
+    >>> from sympy import Integer # noqa: F401
+    >>> from sympy.interactive.session import int_to_Integer
+    >>> s = '1.2 + 1/2 - 0x12 + a1'
+    >>> int_to_Integer(s)
+    '1.2 +Integer (1 )/Integer (2 )-Integer (0x12 )+a1 '
+    >>> s = 'print (1/2)'
+    >>> int_to_Integer(s)
+    'print (Integer (1 )/Integer (2 ))'
+    >>> exec(s)
+    0.5
+    >>> exec(int_to_Integer(s))
+    1/2
+    """
+    from tokenize import generate_tokens, untokenize, NUMBER, NAME, OP
+    from io import StringIO
+
+    def _is_int(num):
+        """
+        Returns true if string value num (with token NUMBER) represents an integer.
+        """
+        # XXX: Is there something in the standard library that will do this?
+        if '.' in num or 'j' in num.lower() or 'e' in num.lower():
+            return False
+        return True
+
+    result = []
+    g = generate_tokens(StringIO(s).readline)  # tokenize the string
+    for toknum, tokval, _, _, _ in g:
+        if toknum == NUMBER and _is_int(tokval):  # replace NUMBER tokens
+            result.extend([
+                (NAME, 'Integer'),
+                (OP, '('),
+                (NUMBER, tokval),
+                (OP, ')')
+            ])
+        else:
+            result.append((toknum, tokval))
+    return untokenize(result)
+
+
+def enable_automatic_int_sympification(shell):
+    """
+    Allow IPython to automatically convert integer literals to Integer.
+    """
+    import ast
+    old_run_cell = shell.run_cell
+
+    def my_run_cell(cell, *args, **kwargs):
+        try:
+            # Check the cell for syntax errors.  This way, the syntax error
+            # will show the original input, not the transformed input.  The
+            # downside here is that IPython magic like %timeit will not work
+            # with transformed input (but on the other hand, IPython magic
+            # that doesn't expect transformed input will continue to work).
+            ast.parse(cell)
+        except SyntaxError:
+            pass
+        else:
+            cell = int_to_Integer(cell)
+        return old_run_cell(cell, *args, **kwargs)
+
+    shell.run_cell = my_run_cell
+
+
+def enable_automatic_symbols(shell):
+    """Allow IPython to automatically create symbols (``isympy -a``). """
+    # XXX: This should perhaps use tokenize, like int_to_Integer() above.
+    # This would avoid re-executing the code, which can lead to subtle
+    # issues.  For example:
+    #
+    # In [1]: a = 1
+    #
+    # In [2]: for i in range(10):
+    #    ...:     a += 1
+    #    ...:
+    #
+    # In [3]: a
+    # Out[3]: 11
+    #
+    # In [4]: a = 1
+    #
+    # In [5]: for i in range(10):
+    #    ...:     a += 1
+    #    ...:     print b
+    #    ...:
+    # b
+    # b
+    # b
+    # b
+    # b
+    # b
+    # b
+    # b
+    # b
+    # b
+    #
+    # In [6]: a
+    # Out[6]: 12
+    #
+    # Note how the for loop is executed again because `b` was not defined, but `a`
+    # was already incremented once, so the result is that it is incremented
+    # multiple times.
+
+    import re
+    re_nameerror = re.compile(
+        "name '(?P<symbol>[A-Za-z_][A-Za-z0-9_]*)' is not defined")
+
+    def _handler(self, etype, value, tb, tb_offset=None):
+        """Handle :exc:`NameError` exception and allow injection of missing symbols. """
+        if etype is NameError and tb.tb_next and not tb.tb_next.tb_next:
+            match = re_nameerror.match(str(value))
+
+            if match is not None:
+                # XXX: Make sure Symbol is in scope. Otherwise you'll get infinite recursion.
+                self.run_cell("%(symbol)s = Symbol('%(symbol)s')" %
+                              {'symbol': match.group("symbol")}, store_history=False)
+
+                try:
+                    code = self.user_ns['In'][-1]
+                except (KeyError, IndexError):
+                    pass
+                else:
+                    self.run_cell(code, store_history=False)
+                    return None
+                finally:
+                    self.run_cell("del %s" % match.group("symbol"),
+                                  store_history=False)
+
+        stb = self.InteractiveTB.structured_traceback(
+            etype, value, tb, tb_offset=tb_offset)
+        self._showtraceback(etype, value, stb)
+
+    shell.set_custom_exc((NameError,), _handler)
+
+
+def init_ipython_session(shell=None, argv=[], auto_symbols=False, auto_int_to_Integer=False):
+    """Construct new IPython session. """
+    import IPython
+
+    if version_tuple(IPython.__version__) >= version_tuple('0.11'):
+        if not shell:
+            # use an app to parse the command line, and init config
+            # IPython 1.0 deprecates the frontend module, so we import directly
+            # from the terminal module to prevent a deprecation message from being
+            # shown.
+            if version_tuple(IPython.__version__) >= version_tuple('1.0'):
+                from IPython.terminal import ipapp
+            else:
+                from IPython.frontend.terminal import ipapp
+            app = ipapp.TerminalIPythonApp()
+
+            # don't draw IPython banner during initialization:
+            app.display_banner = False
+            app.initialize(argv)
+
+            shell = app.shell
+
+        if auto_symbols:
+            enable_automatic_symbols(shell)
+        if auto_int_to_Integer:
+            enable_automatic_int_sympification(shell)
+
+        return shell
+    else:
+        from IPython.Shell import make_IPython
+        return make_IPython(argv)
+
+
+def init_python_session():
+    """Construct new Python session. """
+    from code import InteractiveConsole
+
+    class SymPyConsole(InteractiveConsole):
+        """An interactive console with readline support. """
+
+        def __init__(self):
+            ns_locals = {}
+            InteractiveConsole.__init__(self, locals=ns_locals)
+            try:
+                import rlcompleter
+                import readline
+            except ImportError:
+                pass
+            else:
+                import os
+                import atexit
+
+                readline.set_completer(rlcompleter.Completer(ns_locals).complete)
+                readline.parse_and_bind('tab: complete')
+
+                if hasattr(readline, 'read_history_file'):
+                    history = os.path.expanduser('~/.sympy-history')
+
+                    try:
+                        readline.read_history_file(history)
+                    except OSError:
+                        pass
+
+                    atexit.register(readline.write_history_file, history)
+
+    return SymPyConsole()
+
+
+def init_session(ipython=None, pretty_print=True, order=None,
+                 use_unicode=None, use_latex=None, quiet=False, auto_symbols=False,
+                 auto_int_to_Integer=False, str_printer=None, pretty_printer=None,
+                 latex_printer=None, argv=[]):
+    """
+    Initialize an embedded IPython or Python session. The IPython session is
+    initiated with the --pylab option, without the numpy imports, so that
+    matplotlib plotting can be interactive.
+
+    Parameters
+    ==========
+
+    pretty_print: boolean
+        If True, use pretty_print to stringify;
+        if False, use sstrrepr to stringify.
+    order: string or None
+        There are a few different settings for this parameter:
+        lex (default), which is lexographic order;
+        grlex, which is graded lexographic order;
+        grevlex, which is reversed graded lexographic order;
+        old, which is used for compatibility reasons and for long expressions;
+        None, which sets it to lex.
+    use_unicode: boolean or None
+        If True, use unicode characters;
+        if False, do not use unicode characters.
+    use_latex: boolean or None
+        If True, use latex rendering if IPython GUI's;
+        if False, do not use latex rendering.
+    quiet: boolean
+        If True, init_session will not print messages regarding its status;
+        if False, init_session will print messages regarding its status.
+    auto_symbols: boolean
+        If True, IPython will automatically create symbols for you.
+        If False, it will not.
+        The default is False.
+    auto_int_to_Integer: boolean
+        If True, IPython will automatically wrap int literals with Integer, so
+        that things like 1/2 give Rational(1, 2).
+        If False, it will not.
+        The default is False.
+    ipython: boolean or None
+        If True, printing will initialize for an IPython console;
+        if False, printing will initialize for a normal console;
+        The default is None, which automatically determines whether we are in
+        an ipython instance or not.
+    str_printer: function, optional, default=None
+        A custom string printer function. This should mimic
+        sympy.printing.sstrrepr().
+    pretty_printer: function, optional, default=None
+        A custom pretty printer. This should mimic sympy.printing.pretty().
+    latex_printer: function, optional, default=None
+        A custom LaTeX printer. This should mimic sympy.printing.latex()
+        This should mimic sympy.printing.latex().
+    argv: list of arguments for IPython
+        See sympy.bin.isympy for options that can be used to initialize IPython.
+
+    See Also
+    ========
+
+    sympy.interactive.printing.init_printing: for examples and the rest of the parameters.
+
+
+    Examples
+    ========
+
+    >>> from sympy import init_session, Symbol, sin, sqrt
+    >>> sin(x) #doctest: +SKIP
+    NameError: name 'x' is not defined
+    >>> init_session() #doctest: +SKIP
+    >>> sin(x) #doctest: +SKIP
+    sin(x)
+    >>> sqrt(5) #doctest: +SKIP
+      ___
+    \\/ 5
+    >>> init_session(pretty_print=False) #doctest: +SKIP
+    >>> sqrt(5) #doctest: +SKIP
+    sqrt(5)
+    >>> y + x + y**2 + x**2 #doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_session(order='grlex') #doctest: +SKIP
+    >>> y + x + y**2 + x**2 #doctest: +SKIP
+    x**2 + y**2 + x + y
+    >>> init_session(order='grevlex') #doctest: +SKIP
+    >>> y * x**2 + x * y**2 #doctest: +SKIP
+    x**2*y + x*y**2
+    >>> init_session(order='old') #doctest: +SKIP
+    >>> x**2 + y**2 + x + y #doctest: +SKIP
+    x + y + x**2 + y**2
+    >>> theta = Symbol('theta') #doctest: +SKIP
+    >>> theta #doctest: +SKIP
+    theta
+    >>> init_session(use_unicode=True) #doctest: +SKIP
+    >>> theta # doctest: +SKIP
+    \u03b8
+    """
+    import sys
+
+    in_ipython = False
+
+    if ipython is not False:
+        try:
+            import IPython
+        except ImportError:
+            if ipython is True:
+                raise RuntimeError("IPython is not available on this system")
+            ip = None
+        else:
+            try:
+                from IPython import get_ipython
+                ip = get_ipython()
+            except ImportError:
+                ip = None
+        in_ipython = bool(ip)
+        if ipython is None:
+            ipython = in_ipython
+
+    if ipython is False:
+        ip = init_python_session()
+        mainloop = ip.interact
+    else:
+        ip = init_ipython_session(ip, argv=argv, auto_symbols=auto_symbols,
+                                  auto_int_to_Integer=auto_int_to_Integer)
+
+        if version_tuple(IPython.__version__) >= version_tuple('0.11'):
+            # runsource is gone, use run_cell instead, which doesn't
+            # take a symbol arg.  The second arg is `store_history`,
+            # and False means don't add the line to IPython's history.
+            ip.runsource = lambda src, symbol='exec': ip.run_cell(src, False)
+
+            # Enable interactive plotting using pylab.
+            try:
+                ip.enable_pylab(import_all=False)
+            except Exception:
+                # Causes an import error if matplotlib is not installed.
+                # Causes other errors (depending on the backend) if there
+                # is no display, or if there is some problem in the
+                # backend, so we have a bare "except Exception" here
+                pass
+        if not in_ipython:
+            mainloop = ip.mainloop
+
+    if auto_symbols and (not ipython or version_tuple(IPython.__version__) < version_tuple('0.11')):
+        raise RuntimeError("automatic construction of symbols is possible only in IPython 0.11 or above")
+    if auto_int_to_Integer and (not ipython or version_tuple(IPython.__version__) < version_tuple('0.11')):
+        raise RuntimeError("automatic int to Integer transformation is possible only in IPython 0.11 or above")
+
+    _preexec_source = preexec_source
+
+    ip.runsource(_preexec_source, symbol='exec')
+    init_printing(pretty_print=pretty_print, order=order,
+                  use_unicode=use_unicode, use_latex=use_latex, ip=ip,
+                  str_printer=str_printer, pretty_printer=pretty_printer,
+                  latex_printer=latex_printer)
+
+    message = _make_message(ipython, quiet, _preexec_source)
+
+    if not in_ipython:
+        print(message)
+        mainloop()
+        sys.exit('Exiting ...')
+    else:
+        print(message)
+        import atexit
+        atexit.register(lambda: print("Exiting ...\n"))

llmeval-env/lib/python3.10/site-packages/sympy/interactive/traversal.py

@@ -0,0 +1,95 @@
+from sympy.core.basic import Basic
+from sympy.printing import pprint
+
+import random
+
+def interactive_traversal(expr):
+    """Traverse a tree asking a user which branch to choose. """
+
+    RED, BRED = '\033[0;31m', '\033[1;31m'
+    GREEN, BGREEN = '\033[0;32m', '\033[1;32m'
+    YELLOW, BYELLOW = '\033[0;33m', '\033[1;33m'  # noqa
+    BLUE, BBLUE = '\033[0;34m', '\033[1;34m'      # noqa
+    MAGENTA, BMAGENTA = '\033[0;35m', '\033[1;35m'# noqa
+    CYAN, BCYAN = '\033[0;36m', '\033[1;36m'      # noqa
+    END = '\033[0m'
+
+    def cprint(*args):
+        print("".join(map(str, args)) + END)
+
+    def _interactive_traversal(expr, stage):
+        if stage > 0:
+            print()
+
+        cprint("Current expression (stage ", BYELLOW, stage, END, "):")
+        print(BCYAN)
+        pprint(expr)
+        print(END)
+
+        if isinstance(expr, Basic):
+            if expr.is_Add:
+                args = expr.as_ordered_terms()
+            elif expr.is_Mul:
+                args = expr.as_ordered_factors()
+            else:
+                args = expr.args
+        elif hasattr(expr, "__iter__"):
+            args = list(expr)
+        else:
+            return expr
+
+        n_args = len(args)
+
+        if not n_args:
+            return expr
+
+        for i, arg in enumerate(args):
+            cprint(GREEN, "[", BGREEN, i, GREEN, "] ", BLUE, type(arg), END)
+            pprint(arg)
+            print()
+
+        if n_args == 1:
+            choices = '0'
+        else:
+            choices = '0-%d' % (n_args - 1)
+
+        try:
+            choice = input("Your choice [%s,f,l,r,d,?]: " % choices)
+        except EOFError:
+            result = expr
+            print()
+        else:
+            if choice == '?':
+                cprint(RED, "%s - select subexpression with the given index" %
+                       choices)
+                cprint(RED, "f - select the first subexpression")
+                cprint(RED, "l - select the last subexpression")
+                cprint(RED, "r - select a random subexpression")
+                cprint(RED, "d - done\n")
+
+                result = _interactive_traversal(expr, stage)
+            elif choice in ('d', ''):
+                result = expr
+            elif choice == 'f':
+                result = _interactive_traversal(args[0], stage + 1)
+            elif choice == 'l':
+                result = _interactive_traversal(args[-1], stage + 1)
+            elif choice == 'r':
+                result = _interactive_traversal(random.choice(args), stage + 1)
+            else:
+                try:
+                    choice = int(choice)
+                except ValueError:
+                    cprint(BRED,
+                           "Choice must be a number in %s range\n" % choices)
+                    result = _interactive_traversal(expr, stage)
+                else:
+                    if choice < 0 or choice >= n_args:
+                        cprint(BRED, "Choice must be in %s range\n" % choices)
+                        result = _interactive_traversal(expr, stage)
+                    else:
+                        result = _interactive_traversal(args[choice], stage + 1)
+
+        return result
+
+    return _interactive_traversal(expr, 0)

llmeval-env/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()

llmeval-env/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)

llmeval-env/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

llmeval-env/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)

llmeval-env/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)

llmeval-env/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)

llmeval-env/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)

llmeval-env/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)

llmeval-env/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()

llmeval-env/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()

llmeval-env/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

llmeval-env/lib/python3.10/site-packages/sympy/stats/sampling/sample_numpy.py

@@ -0,0 +1,105 @@
+from functools import singledispatch
+
+from sympy.external import import_module
+from sympy.stats.crv_types import BetaDistribution, ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
+    LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, FDistributionDistribution, GumbelDistribution, LaplaceDistribution, \
+    LogisticDistribution, RayleighDistribution, TriangularDistribution
+from sympy.stats.drv_types import GeometricDistribution, PoissonDistribution, ZetaDistribution
+from sympy.stats.frv_types import BinomialDistribution, HypergeometricDistribution
+
+
+numpy = import_module('numpy')
+
+
+@singledispatch
+def do_sample_numpy(dist, size, rand_state):
+    return None
+
+
+# CRV:
+
+@do_sample_numpy.register(BetaDistribution)
+def _(dist: BetaDistribution, size, rand_state):
+    return rand_state.beta(a=float(dist.alpha), b=float(dist.beta), size=size)
+
+
+@do_sample_numpy.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution, size, rand_state):
+    return rand_state.chisquare(df=float(dist.k), size=size)
+
+
+@do_sample_numpy.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution, size, rand_state):
+    return rand_state.exponential(1 / float(dist.rate), size=size)
+
+@do_sample_numpy.register(FDistributionDistribution)
+def _(dist: FDistributionDistribution, size, rand_state):
+    return rand_state.f(dfnum = float(dist.d1), dfden = float(dist.d2), size=size)
+
+@do_sample_numpy.register(GammaDistribution)
+def _(dist: GammaDistribution, size, rand_state):
+    return rand_state.gamma(shape = float(dist.k), scale = float(dist.theta), size=size)
+
+@do_sample_numpy.register(GumbelDistribution)
+def _(dist: GumbelDistribution, size, rand_state):
+    return rand_state.gumbel(loc = float(dist.mu), scale = float(dist.beta), size=size)
+
+@do_sample_numpy.register(LaplaceDistribution)
+def _(dist: LaplaceDistribution, size, rand_state):
+    return rand_state.laplace(loc = float(dist.mu), scale = float(dist.b), size=size)
+
+@do_sample_numpy.register(LogisticDistribution)
+def _(dist: LogisticDistribution, size, rand_state):
+    return rand_state.logistic(loc = float(dist.mu), scale = float(dist.s), size=size)
+
+@do_sample_numpy.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution, size, rand_state):
+    return rand_state.lognormal(mean = float(dist.mean), sigma = float(dist.std), size=size)
+
+@do_sample_numpy.register(NormalDistribution)
+def _(dist: NormalDistribution, size, rand_state):
+    return rand_state.normal(loc = float(dist.mean), scale = float(dist.std), size=size)
+
+@do_sample_numpy.register(RayleighDistribution)
+def _(dist: RayleighDistribution, size, rand_state):
+    return rand_state.rayleigh(scale = float(dist.sigma), size=size)
+
+@do_sample_numpy.register(ParetoDistribution)
+def _(dist: ParetoDistribution, size, rand_state):
+    return (numpy.random.pareto(a=float(dist.alpha), size=size) + 1) * float(dist.xm)
+
+@do_sample_numpy.register(TriangularDistribution)
+def _(dist: TriangularDistribution, size, rand_state):
+    return rand_state.triangular(left = float(dist.a), mode = float(dist.b), right = float(dist.c), size=size)
+
+@do_sample_numpy.register(UniformDistribution)
+def _(dist: UniformDistribution, size, rand_state):
+    return rand_state.uniform(low=float(dist.left), high=float(dist.right), size=size)
+
+
+# DRV:
+
+@do_sample_numpy.register(GeometricDistribution)
+def _(dist: GeometricDistribution, size, rand_state):
+    return rand_state.geometric(p=float(dist.p), size=size)
+
+
+@do_sample_numpy.register(PoissonDistribution)
+def _(dist: PoissonDistribution, size, rand_state):
+    return rand_state.poisson(lam=float(dist.lamda), size=size)
+
+
+@do_sample_numpy.register(ZetaDistribution)
+def _(dist: ZetaDistribution, size, rand_state):
+    return rand_state.zipf(a=float(dist.s), size=size)
+
+
+# FRV:
+
+@do_sample_numpy.register(BinomialDistribution)
+def _(dist: BinomialDistribution, size, rand_state):
+    return rand_state.binomial(n=int(dist.n), p=float(dist.p), size=size)
+
+@do_sample_numpy.register(HypergeometricDistribution)
+def _(dist: HypergeometricDistribution, size, rand_state):
+    return rand_state.hypergeometric(ngood = int(dist.N), nbad = int(dist.m), nsample = int(dist.n), size=size)

llmeval-env/lib/python3.10/site-packages/sympy/stats/sampling/sample_pymc.py

@@ -0,0 +1,99 @@
+from functools import singledispatch
+from sympy.external import import_module
+from sympy.stats.crv_types import BetaDistribution, CauchyDistribution, ChiSquaredDistribution, ExponentialDistribution, \
+    GammaDistribution, LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, \
+    GaussianInverseDistribution
+from sympy.stats.drv_types import PoissonDistribution, GeometricDistribution, NegativeBinomialDistribution
+from sympy.stats.frv_types import BinomialDistribution, BernoulliDistribution
+
+
+try:
+    import pymc
+except ImportError:
+    pymc = import_module('pymc3')
+
+@singledispatch
+def do_sample_pymc(dist):
+    return None
+
+
+# CRV:
+
+@do_sample_pymc.register(BetaDistribution)
+def _(dist: BetaDistribution):
+    return pymc.Beta('X', alpha=float(dist.alpha), beta=float(dist.beta))
+
+
+@do_sample_pymc.register(CauchyDistribution)
+def _(dist: CauchyDistribution):
+    return pymc.Cauchy('X', alpha=float(dist.x0), beta=float(dist.gamma))
+
+
+@do_sample_pymc.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution):
+    return pymc.ChiSquared('X', nu=float(dist.k))
+
+
+@do_sample_pymc.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution):
+    return pymc.Exponential('X', lam=float(dist.rate))
+
+
+@do_sample_pymc.register(GammaDistribution)
+def _(dist: GammaDistribution):
+    return pymc.Gamma('X', alpha=float(dist.k), beta=1 / float(dist.theta))
+
+
+@do_sample_pymc.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution):
+    return pymc.Lognormal('X', mu=float(dist.mean), sigma=float(dist.std))
+
+
+@do_sample_pymc.register(NormalDistribution)
+def _(dist: NormalDistribution):
+    return pymc.Normal('X', float(dist.mean), float(dist.std))
+
+
+@do_sample_pymc.register(GaussianInverseDistribution)
+def _(dist: GaussianInverseDistribution):
+    return pymc.Wald('X', mu=float(dist.mean), lam=float(dist.shape))
+
+
+@do_sample_pymc.register(ParetoDistribution)
+def _(dist: ParetoDistribution):
+    return pymc.Pareto('X', alpha=float(dist.alpha), m=float(dist.xm))
+
+
+@do_sample_pymc.register(UniformDistribution)
+def _(dist: UniformDistribution):
+    return pymc.Uniform('X', lower=float(dist.left), upper=float(dist.right))
+
+
+# DRV:
+
+@do_sample_pymc.register(GeometricDistribution)
+def _(dist: GeometricDistribution):
+    return pymc.Geometric('X', p=float(dist.p))
+
+
+@do_sample_pymc.register(NegativeBinomialDistribution)
+def _(dist: NegativeBinomialDistribution):
+    return pymc.NegativeBinomial('X', mu=float((dist.p * dist.r) / (1 - dist.p)),
+                                  alpha=float(dist.r))
+
+
+@do_sample_pymc.register(PoissonDistribution)
+def _(dist: PoissonDistribution):
+    return pymc.Poisson('X', mu=float(dist.lamda))
+
+
+# FRV:
+
+@do_sample_pymc.register(BernoulliDistribution)
+def _(dist: BernoulliDistribution):
+    return pymc.Bernoulli('X', p=float(dist.p))
+
+
+@do_sample_pymc.register(BinomialDistribution)
+def _(dist: BinomialDistribution):
+    return pymc.Binomial('X', n=int(dist.n), p=float(dist.p))

llmeval-env/lib/python3.10/site-packages/sympy/stats/sampling/sample_scipy.py

@@ -0,0 +1,167 @@
+from functools import singledispatch
+
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.exponential import exp
+from sympy.utilities.lambdify import lambdify
+from sympy.external import import_module
+from sympy.stats import DiscreteDistributionHandmade
+from sympy.stats.crv import SingleContinuousDistribution
+from sympy.stats.crv_types import ChiSquaredDistribution, ExponentialDistribution, GammaDistribution, \
+    LogNormalDistribution, NormalDistribution, ParetoDistribution, UniformDistribution, BetaDistribution, \
+    StudentTDistribution, CauchyDistribution
+from sympy.stats.drv_types import GeometricDistribution, LogarithmicDistribution, NegativeBinomialDistribution, \
+    PoissonDistribution, SkellamDistribution, YuleSimonDistribution, ZetaDistribution
+from sympy.stats.frv import SingleFiniteDistribution
+
+
+scipy = import_module("scipy", import_kwargs={'fromlist':['stats']})
+
+
+@singledispatch
+def do_sample_scipy(dist, size, seed):
+    return None
+
+
+# CRV
+
+@do_sample_scipy.register(SingleContinuousDistribution)
+def _(dist: SingleContinuousDistribution, size, seed):
+    # if we don't need to make a handmade pdf, we won't
+    import scipy.stats
+
+    z = Dummy('z')
+    handmade_pdf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
+
+    class scipy_pdf(scipy.stats.rv_continuous):
+        def _pdf(dist, x):
+            return handmade_pdf(x)
+
+    scipy_rv = scipy_pdf(a=float(dist.set._inf),
+                         b=float(dist.set._sup), name='scipy_pdf')
+    return scipy_rv.rvs(size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ChiSquaredDistribution)
+def _(dist: ChiSquaredDistribution, size, seed):
+    # same parametrisation
+    return scipy.stats.chi2.rvs(df=float(dist.k), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ExponentialDistribution)
+def _(dist: ExponentialDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.expon.html#scipy.stats.expon
+    return scipy.stats.expon.rvs(scale=1 / float(dist.rate), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(GammaDistribution)
+def _(dist: GammaDistribution, size, seed):
+    # https://stackoverflow.com/questions/42150965/how-to-plot-gamma-distribution-with-alpha-and-beta-parameters-in-python
+    return scipy.stats.gamma.rvs(a=float(dist.k), scale=float(dist.theta), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(LogNormalDistribution)
+def _(dist: LogNormalDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.lognorm.html
+    return scipy.stats.lognorm.rvs(scale=float(exp(dist.mean)), s=float(dist.std), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(NormalDistribution)
+def _(dist: NormalDistribution, size, seed):
+    return scipy.stats.norm.rvs(loc=float(dist.mean), scale=float(dist.std), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ParetoDistribution)
+def _(dist: ParetoDistribution, size, seed):
+    # https://stackoverflow.com/questions/42260519/defining-pareto-distribution-in-python-scipy
+    return scipy.stats.pareto.rvs(b=float(dist.alpha), scale=float(dist.xm), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(StudentTDistribution)
+def _(dist: StudentTDistribution, size, seed):
+    return scipy.stats.t.rvs(df=float(dist.nu), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(UniformDistribution)
+def _(dist: UniformDistribution, size, seed):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html
+    return scipy.stats.uniform.rvs(loc=float(dist.left), scale=float(dist.right - dist.left), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(BetaDistribution)
+def _(dist: BetaDistribution, size, seed):
+    # same parametrisation
+    return scipy.stats.beta.rvs(a=float(dist.alpha), b=float(dist.beta), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(CauchyDistribution)
+def _(dist: CauchyDistribution, size, seed):
+    return scipy.stats.cauchy.rvs(loc=float(dist.x0), scale=float(dist.gamma), size=size, random_state=seed)
+
+
+# DRV:
+
+@do_sample_scipy.register(DiscreteDistributionHandmade)
+def _(dist: DiscreteDistributionHandmade, size, seed):
+    from scipy.stats import rv_discrete
+
+    z = Dummy('z')
+    handmade_pmf = lambdify(z, dist.pdf(z), ['numpy', 'scipy'])
+
+    class scipy_pmf(rv_discrete):
+        def _pmf(dist, x):
+            return handmade_pmf(x)
+
+    scipy_rv = scipy_pmf(a=float(dist.set._inf), b=float(dist.set._sup),
+                         name='scipy_pmf')
+    return scipy_rv.rvs(size=size, random_state=seed)
+
+
+@do_sample_scipy.register(GeometricDistribution)
+def _(dist: GeometricDistribution, size, seed):
+    return scipy.stats.geom.rvs(p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(LogarithmicDistribution)
+def _(dist: LogarithmicDistribution, size, seed):
+    return scipy.stats.logser.rvs(p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(NegativeBinomialDistribution)
+def _(dist: NegativeBinomialDistribution, size, seed):
+    return scipy.stats.nbinom.rvs(n=float(dist.r), p=float(dist.p), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(PoissonDistribution)
+def _(dist: PoissonDistribution, size, seed):
+    return scipy.stats.poisson.rvs(mu=float(dist.lamda), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(SkellamDistribution)
+def _(dist: SkellamDistribution, size, seed):
+    return scipy.stats.skellam.rvs(mu1=float(dist.mu1), mu2=float(dist.mu2), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(YuleSimonDistribution)
+def _(dist: YuleSimonDistribution, size, seed):
+    return scipy.stats.yulesimon.rvs(alpha=float(dist.rho), size=size, random_state=seed)
+
+
+@do_sample_scipy.register(ZetaDistribution)
+def _(dist: ZetaDistribution, size, seed):
+    return scipy.stats.zipf.rvs(a=float(dist.s), size=size, random_state=seed)
+
+
+# FRV:
+
+@do_sample_scipy.register(SingleFiniteDistribution)
+def _(dist: SingleFiniteDistribution, size, seed):
+    # scipy can handle with custom distributions
+
+    from scipy.stats import rv_discrete
+    density_ = dist.dict
+    x, y = [], []
+    for k, v in density_.items():
+        x.append(int(k))
+        y.append(float(v))
+    scipy_rv = rv_discrete(name='scipy_rv', values=(x, y))
+    return scipy_rv.rvs(size=size, random_state=seed)