Upload folder using huggingface_hub (part 20)

.gitattributes

@@ -493,3 +493,36 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/sympy/stats/__pycache__/crv_types.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/sympy/stats/tests/__pycache__/test_continuous_rv.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/tensor/__pycache__/tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/tensor/tests/__pycache__/test_tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/utilities/__pycache__/iterables.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_lambdify.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/tests/__pycache__/test_python.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/__pycache__/__init__.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/__pycache__/_meta_registrations.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/__pycache__/_tensor_docs.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/__pycache__/_torch_docs.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/__pycache__/overrides.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_decomp/__pycache__/decompositions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/convert_frame.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/eval_frame.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/guards.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/output_graph.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/symbolic_convert.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/trace_rules.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/__pycache__/utils.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/base.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/builder.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/builtin.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/functions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/higher_order_ops.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/lists.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/misc.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/tensor.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/torch.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_dynamo/variables/__pycache__/user_defined.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_export/serde/__pycache__/serialize.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_functorch/__pycache__/partitioners.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/__pycache__/runtime_wrappers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: sympy
+Version: 1.14.0
+Summary: Computer algebra system (CAS) in Python
+Home-page: https://sympy.org
+Author: SymPy development team
+Author-email: sympy@googlegroups.com
+License: BSD
+Project-URL: Source, https://github.com/sympy/sympy
+Keywords: Math CAS
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: mpmath<1.4,>=1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.1.0; extra == "dev"
+Requires-Dist: hypothesis>=6.70.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SymPy
+
+[![pypi version](https://img.shields.io/pypi/v/sympy.svg)](https://pypi.python.org/pypi/sympy)
+[![Join the chat at https://gitter.im/sympy/sympy](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sympy/sympy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Zenodo Badge](https://zenodo.org/badge/18918/sympy/sympy.svg)](https://zenodo.org/badge/latestdoi/18918/sympy/sympy)
+[![Downloads](https://pepy.tech/badge/sympy/month)](https://pepy.tech/project/sympy)
+[![GitHub Issues](https://img.shields.io/badge/issue_tracking-github-blue.svg)](https://github.com/sympy/sympy/issues)
+[![Git Tutorial](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project)
+[![Powered by NumFocus](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://numfocus.org)
+[![Commits since last release](https://img.shields.io/github/commits-since/sympy/sympy/latest.svg?longCache=true&style=flat-square&logo=git&logoColor=fff)](https://github.com/sympy/sympy/releases)
+
+[![SymPy Banner](https://github.com/sympy/sympy/raw/master/banner.svg)](https://sympy.org/)
+
+
+See the [AUTHORS](AUTHORS) file for the list of authors.
+
+And many more people helped on the SymPy mailing list, reported bugs,
+helped organize SymPy's participation in the Google Summer of Code, the
+Google Highly Open Participation Contest, Google Code-In, wrote and
+blogged about SymPy...
+
+License: New BSD License (see the [LICENSE](LICENSE) file for details) covers all
+files in the sympy repository unless stated otherwise.
+
+Our mailing list is at
+<https://groups.google.com/forum/?fromgroups#!forum/sympy>.
+
+We have a community chat at [Gitter](https://gitter.im/sympy/sympy). Feel
+free to ask us anything there. We have a very welcoming and helpful
+community.
+
+## Download
+
+The recommended installation method is through Anaconda,
+<https://www.anaconda.com/products/distribution>
+
+You can also get the latest version of SymPy from
+<https://pypi.python.org/pypi/sympy/>
+
+To get the git version do
+
+    $ git clone https://github.com/sympy/sympy.git
+
+For other options (tarballs, debs, etc.), see
+<https://docs.sympy.org/dev/install.html>.
+
+## Documentation and Usage
+
+For in-depth instructions on installation and building the
+documentation, see the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html).
+
+Everything is at:
+
+<https://docs.sympy.org/>
+
+You can generate everything at the above site in your local copy of
+SymPy by:
+
+    $ cd doc
+    $ make html
+
+Then the docs will be in <span class="title-ref">\_build/html</span>. If
+you don't want to read that, here is a short usage:
+
+From this directory, start Python and:
+
+``` python
+>>> from sympy import Symbol, cos
+>>> x = Symbol('x')
+>>> e = 1/cos(x)
+>>> print(e.series(x, 0, 10))
+1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + 277*x**8/8064 + O(x**10)
+```
+
+SymPy also comes with a console that is a simple wrapper around the
+classic python console (or IPython when available) that loads the SymPy
+namespace and executes some common commands for you.
+
+To start it, issue:
+
+    $ bin/isympy
+
+from this directory, if SymPy is not installed or simply:
+
+    $ isympy
+
+if SymPy is installed.
+
+## Installation
+
+To install SymPy using PyPI, run the following command:
+
+    $ pip install sympy
+
+To install SymPy using Anaconda, run the following command:
+
+    $ conda install -c anaconda sympy
+
+To install SymPy from GitHub source, first clone SymPy using `git`:
+
+    $ git clone https://github.com/sympy/sympy.git
+
+Then, in the `sympy` repository that you cloned, simply run:
+
+    $ pip install .
+
+See <https://docs.sympy.org/dev/install.html> for more information.
+
+## Contributing
+
+We welcome contributions from anyone, even if you are new to open
+source. Please read our [Introduction to Contributing](https://docs.sympy.org/dev/contributing/introduction-to-contributing.html)
+page and the [SymPy Documentation Style Guide](https://docs.sympy.org/dev/documentation-style-guide.html). If you
+are new and looking for some way to contribute, a good place to start is
+to look at the issues tagged [Easy to Fix](https://github.com/sympy/sympy/issues?q=is%3Aopen+is%3Aissue+label%3A%22Easy+to+Fix%22).
+
+Please note that all participants in this project are expected to follow
+our Code of Conduct. By participating in this project you agree to abide
+by its terms. See [CODE\_OF\_CONDUCT.md](CODE_OF_CONDUCT.md).
+
+## Tests
+
+To execute all tests, run:
+
+    $./setup.py test
+
+in the current directory.
+
+For the more fine-grained running of tests or doctests, use `bin/test`
+or respectively `bin/doctest`. The master branch is automatically tested
+by GitHub Actions.
+
+To test pull requests, use
+[sympy-bot](https://github.com/sympy/sympy-bot).
+
+## Regenerate Experimental <span class="title-ref">LaTeX</span> Parser/Lexer
+
+The parser and lexer were generated with the [ANTLR4](http://antlr4.org)
+toolchain in `sympy/parsing/latex/_antlr` and checked into the repo.
+Presently, most users should not need to regenerate these files, but
+if you plan to work on this feature, you will need the `antlr4`
+command-line tool (and you must ensure that it is in your `PATH`).
+One way to get it is:
+
+    $ conda install -c conda-forge antlr=4.11.1
+
+Alternatively, follow the instructions on the ANTLR website and download
+the `antlr-4.11.1-complete.jar`. Then export the `CLASSPATH` as instructed
+and instead of creating `antlr4` as an alias, make it an executable file
+with the following contents:
+``` bash
+#!/bin/bash
+java -jar /usr/local/lib/antlr-4.11.1-complete.jar "$@"
+```
+
+After making changes to `sympy/parsing/latex/LaTeX.g4`, run:
+
+    $ ./setup.py antlr
+
+## Clean
+
+To clean everything (thus getting the same tree as in the repository):
+
+    $ git clean -Xdf
+
+which will clear everything ignored by `.gitignore`, and:
+
+    $ git clean -df
+
+to clear all untracked files. You can revert the most recent changes in
+git with:
+
+    $ git reset --hard
+
+WARNING: The above commands will all clear changes you may have made,
+and you will lose them forever. Be sure to check things with `git
+status`, `git diff`, `git clean -Xn`, and `git clean -n` before doing any
+of those.
+
+## Bugs
+
+Our issue tracker is at <https://github.com/sympy/sympy/issues>. Please
+report any bugs that you find. Or, even better, fork the repository on
+GitHub and create a pull request. We welcome all changes, big or small,
+and we will help you make the pull request if you are new to git (just
+ask on our mailing list or Gitter Channel). If you further have any queries, you can find answers
+on Stack Overflow using the [sympy](https://stackoverflow.com/questions/tagged/sympy) tag.
+
+## Brief History
+
+SymPy was started by Ondřej Čertík in 2005, he wrote some code during
+the summer, then he wrote some more code during summer 2006. In February
+2007, Fabian Pedregosa joined the project and helped fix many things,
+contributed documentation, and made it alive again. 5 students (Mateusz
+Paprocki, Brian Jorgensen, Jason Gedge, Robert Schwarz, and Chris Wu)
+improved SymPy incredibly during summer 2007 as part of the Google
+Summer of Code. Pearu Peterson joined the development during the summer
+2007 and he has made SymPy much more competitive by rewriting the core
+from scratch, which has made it from 10x to 100x faster. Jurjen N.E. Bos
+has contributed pretty-printing and other patches. Fredrik Johansson has
+written mpmath and contributed a lot of patches.
+
+SymPy has participated in every Google Summer of Code since 2007. You
+can see <https://github.com/sympy/sympy/wiki#google-summer-of-code> for
+full details. Each year has improved SymPy by bounds. Most of SymPy's
+development has come from Google Summer of Code students.
+
+In 2011, Ondřej Čertík stepped down as lead developer, with Aaron
+Meurer, who also started as a Google Summer of Code student, taking his
+place. Ondřej Čertík is still active in the community but is too busy
+with work and family to play a lead development role.
+
+Since then, a lot more people have joined the development and some
+people have also left. You can see the full list in doc/src/aboutus.rst,
+or online at:
+
+<https://docs.sympy.org/dev/aboutus.html#sympy-development-team>
+
+The git history goes back to 2007 when development moved from svn to hg.
+To see the history before that point, look at
+<https://github.com/sympy/sympy-old>.
+
+You can use git to see the biggest developers. The command:
+
+    $ git shortlog -ns
+
+will show each developer, sorted by commits to the project. The command:
+
+    $ git shortlog -ns --since="1 year"
+
+will show the top developers from the last year.
+
+## Citation
+
+To cite SymPy in publications use
+
+> Meurer A, Smith CP, Paprocki M, Čertík O, Kirpichev SB, Rocklin M,
+> Kumar A, Ivanov S, Moore JK, Singh S, Rathnayake T, Vig S, Granger BE,
+> Muller RP, Bonazzi F, Gupta H, Vats S, Johansson F, Pedregosa F, Curry
+> MJ, Terrel AR, Roučka Š, Saboo A, Fernando I, Kulal S, Cimrman R,
+> Scopatz A. (2017) SymPy: symbolic computing in Python. *PeerJ Computer
+> Science* 3:e103 <https://doi.org/10.7717/peerj-cs.103>
+
+A BibTeX entry for LaTeX users is
+
+``` bibtex
+@article{10.7717/peerj-cs.103,
+ title = {SymPy: symbolic computing in Python},
+ author = {Meurer, Aaron and Smith, Christopher P. and Paprocki, Mateusz and \v{C}ert\'{i}k, Ond\v{r}ej and Kirpichev, Sergey B. and Rocklin, Matthew and Kumar, Amit and Ivanov, Sergiu and Moore, Jason K. and Singh, Sartaj and Rathnayake, Thilina and Vig, Sean and Granger, Brian E. and Muller, Richard P. and Bonazzi, Francesco and Gupta, Harsh and Vats, Shivam and Johansson, Fredrik and Pedregosa, Fabian and Curry, Matthew J. and Terrel, Andy R. and Rou\v{c}ka, \v{S}t\v{e}p\'{a}n and Saboo, Ashutosh and Fernando, Isuru and Kulal, Sumith and Cimrman, Robert and Scopatz, Anthony},
+ year = 2017,
+ month = Jan,
+ keywords = {Python, Computer algebra system, Symbolics},
+ abstract = {
+            SymPy is an open-source computer algebra system written in pure Python. It is built with a focus on extensibility and ease of use, through both interactive and programmatic applications. These characteristics have led SymPy to become a popular symbolic library for the scientific Python ecosystem. This paper presents the architecture of SymPy, a description of its features, and a discussion of select submodules. The supplementary material provides additional examples and further outlines details of the architecture and features of SymPy.
+         },
+ volume = 3,
+ pages = {e103},
+ journal = {PeerJ Computer Science},
+ issn = {2376-5992},
+ url = {https://doi.org/10.7717/peerj-cs.103},
+ doi = {10.7717/peerj-cs.103}
+}
+```
+
+SymPy is BSD licensed, so you are free to use it whatever you like, be
+it academic, commercial, creating forks or derivatives, as long as you
+copy the BSD statement if you redistribute it (see the LICENSE file for
+details). That said, although not required by the SymPy license, if it
+is convenient for you, please cite SymPy when using it in your work and
+also consider contributing all your changes back, so that we can
+incorporate it and all of us will benefit in the end.

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+isympy = isympy:main

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/AUTHORS

@@ -0,0 +1,1379 @@
+All people who contributed to SymPy by sending at least a patch or
+more (in the order of the date of their first contribution), except
+those who explicitly didn't want to be mentioned. People with a * next
+to their names are not found in the metadata of the git history. This
+file is generated automatically by running `./bin/authors_update.py`.
+
+There are a total of 1371 authors.
+
+Ondřej Čertík <ondrej@certik.cz>
+Fabian Pedregosa <fabian@fseoane.net>
+Jurjen N.E. Bos <jnebos@gmail.com>
+Mateusz Paprocki <mattpap@gmail.com>
+*Marc-Etienne M.Leveille <protonyc@gmail.com>
+Brian Jorgensen <brian.jorgensen@gmail.com>
+Jason Gedge <inferno1386@gmail.com>
+Robert Schwarz <lethargo@googlemail.com>
+Pearu Peterson <pearu.peterson@gmail.com>
+Fredrik Johansson <fredrik.johansson@gmail.com>
+Chris Wu <chris.wu@gmail.com>
+*Ulrich Hecht <ulrich.hecht@gmail.com>
+Goutham Lakshminarayan <dl.goutham@gmail.com>
+David Lawrence <dmlawrence@gmail.com>
+Jaroslaw Tworek <dev.jrx@gmail.com>
+David Marek <h4wk.cz@gmail.com>
+Bernhard R. Link <brlink@debian.org>
+Andrej Tokarčík <androsis@gmail.com>
+Or Dvory <gidesa@gmail.com>
+Saroj Adhikari <adh.saroj@gmail.com>
+Pauli Virtanen <pav@iki.fi>
+Robert Kern <robert.kern@gmail.com>
+James Aspnes <aspnes@cs.yale.edu>
+Nimish Telang <ntelang@gmail.com>
+Abderrahim Kitouni <a.kitouni@gmail.com>
+Pan Peng <pengpanster@gmail.com>
+Friedrich Hagedorn <friedrich_h@gmx.de>
+Elrond der Elbenfuerst <elrond+sympy.org@samba-tng.org>
+Rizgar Mella <rizgar.mella@gmail.com>
+Felix Kaiser <felix.kaiser@fxkr.net>
+Roberto Nobrega <rwnobrega@gmail.com>
+David Roberts <dvdr18@gmail.com>
+Sebastian Krämer <basti.kr@gmail.com>
+Vinzent Steinberg <vinzent.steinberg@gmail.com>
+Riccardo Gori <goriccardo@gmail.com>
+Case Van Horsen <casevh@gmail.com>
+Stepan Roucka <stepan@roucka.eu>
+Ali Raza Syed <arsyed@gmail.com>
+Stefano Maggiolo <s.maggiolo@gmail.com>
+Robert Cimrman <cimrman3@ntc.zcu.cz>
+Bastian Weber <bastian.weber@gmx-topmail.de>
+Sebastian Krause <sebastian.krause@gmx.de>
+Sebastian Kreft <skreft@gmail.com>
+*Dan <coolg49964@gmail.com>
+Alan Bromborsky <abrombo@verizon.net>
+Boris Timokhin <qoqenator@gmail.com>
+Robert <average.programmer@gmail.com>
+Andy R. Terrel <aterrel@uchicago.edu>
+Hubert Tsang <intsangity@gmail.com>
+Konrad Meyer <konrad.meyer@gmail.com>
+Henrik Johansson <henjo2006@gmail.com>
+Priit Laes <plaes@plaes.org>
+Freddie Witherden <freddie@witherden.org>
+Brian E. Granger <ellisonbg@gmail.com>
+Andrew Straw <strawman@astraw.com>
+Kaifeng Zhu <cafeeee@gmail.com>
+Ted Horst <ted.horst@earthlink.net>
+Andrew Docherty <andrewd@maths.usyd.edu.au>
+Akshay Srinivasan <akshaysrinivasan@gmail.com>
+Aaron Meurer <asmeurer@gmail.com>
+Barry Wardell <barry.wardell@gmail.com>
+Tomasz Buchert <thinred@gmail.com>
+Vinay Kumar <gnulinooks@gmail.com>
+Johann Cohen-Tanugi <johann.cohentanugi@gmail.com>
+Jochen Voss <voss@seehuhn.de>
+Luke Peterson <hazelnusse@gmail.com>
+Chris Smith <smichr@gmail.com>
+Thomas Sidoti <TSidoti@gmail.com>
+Florian Mickler <florian@mickler.org>
+Nicolas Pourcelot <nicolas.pourcelot@gmail.com>
+Ben Goodrich <goodrich.ben@gmail.com>
+Toon Verstraelen <Toon.Verstraelen@UGent.be>
+Ronan Lamy <ronan.lamy@gmail.com>
+James Abbatiello <abbeyj@gmail.com>
+Ryan Krauss <ryanlists@gmail.com>
+Bill Flynn <wflynny@gmail.com>
+Kevin Goodsell <kevin-opensource@omegacrash.net>
+Jorn Baayen <jorn.baayen@gmail.com>
+Eh Tan <tan2tan2@gmail.com>
+Renato Coutinho <renato.coutinho@gmail.com>
+Oscar Benjamin <oscar.j.benjamin@gmail.com>
+Øyvind Jensen <jensen.oyvind@gmail.com>
+Julio Idichekop Filho <idichekop@yahoo.com.br>
+Łukasz Pankowski <lukpank@o2.pl>
+*Chu-Ching Huang <cchuang@mail.cgu.edu.tw>
+Fernando Perez <Fernando.Perez@berkeley.edu>
+Raffaele De Feo <alberthilbert@gmail.com>
+Christian Muise <christian.muise@gmail.com>
+Matt Curry <mattjcurry@gmail.com>
+Kazuo Thow <kazuo.thow@gmail.com>
+Christian Schubert <chr.schubert@gmx.de>
+Jezreel Ng <jezreel@gmail.com>
+James Pearson <xiong.chiamiov@gmail.com>
+Matthew Brett <matthew.brett@gmail.com>
+Addison Cugini <ajcugini@gmail.com>
+Nicholas J.S. Kinar <n.kinar@usask.ca>
+Harold Erbin <harold.erbin@gmail.com>
+Thomas Dixon <thom@thomdixon.org>
+Cristóvão Sousa <crisjss@gmail.com>
+Andre de Fortier Smit <freevryheid@gmail.com>
+Mark Dewing <markdewing@gmail.com>
+Alexey U. Gudchenko <proga@goodok.ru>
+Gary Kerr <gary.kerr@blueyonder.co.uk>
+Sherjil Ozair <sherjilozair@gmail.com>
+Oleksandr Gituliar <gituliar@gmail.com>
+Sean Vig <sean.v.775@gmail.com>
+Prafullkumar P. Tale <hector1618@gmail.com>
+Vladimir Perić <vlada.peric@gmail.com>
+Tom Bachmann <e_mc_h2@web.de>
+Yuri Karadzhov <yuri.karadzhov@gmail.com>
+Vladimir Lagunov <werehuman@gmail.com>
+Matthew Rocklin <mrocklin@cs.uchicago.edu>
+Saptarshi Mandal <sapta.iitkgp@gmail.com>
+Gilbert Gede <gilbertgede@gmail.com>
+Anatolii Koval <weralwolf@gmail.com>
+Tomo Lazovich <lazovich@gmail.com>
+Pavel Fedotov <fedotovp@gmail.com>
+Jack McCaffery <jpmccaffery@gmail.com>
+Jeremias Yehdegho <j.yehdegho@gmail.com>
+Kibeom Kim <kk1674@nyu.edu>
+Gregory Ksionda <ksiondag846@gmail.com>
+Tomáš Bambas <tomas.bambas@gmail.com>
+Raymond Wong <rayman_407@yahoo.com>
+Luca Weihs <astronomicalcuriosity@gmail.com>
+Shai 'Deshe' Wyborski <shaide@cs.huji.ac.il>
+Thomas Wiecki <thomas.wiecki@gmail.com>
+Óscar Nájera <najera.oscar@gmail.com>
+Mario Pernici <mario.pernici@gmail.com>
+Benjamin McDonald <mcdonald.ben@gmail.com>
+Sam Magura <samtheman132@gmail.com>
+Stefan Krastanov <krastanov.stefan@gmail.com>
+Bradley Froehle <brad.froehle@gmail.com>
+Min Ragan-Kelley <benjaminrk@gmail.com>
+Emma Hogan <ehogan@gemini.edu>
+Nikhil Sarda <diff.operator@gmail.com>
+Julien Rioux <julien.rioux@gmail.com>
+Roberto Colistete, Jr. <roberto.colistete@gmail.com>
+Raoul Bourquin <raoulb@bluewin.ch>
+Gert-Ludwig Ingold <gert.ingold@physik.uni-augsburg.de>
+Srinivas Vasudevan <srvasude@gmail.com>
+Jason Moore <moorepants@gmail.com>
+Miha Marolt <tloramus@gmail.com>
+Tim Lahey <tim.lahey@gmail.com>
+Luis Garcia <ppn.online@me.com>
+Matt Rajca <matt.rajca@me.com>
+David Li <l33tnerd.li@gmail.com>
+Alexandr Gudulin <alexandr.gudulin@gmail.com>
+Bilal Akhtar <bilalakhtar@ubuntu.com>
+Grzegorz Świrski <sognat@gmail.com>
+Matt Habel <habelinc@gmail.com>
+David Ju <Sgtmook314@gmail.com>
+Nichita Utiu <nikita.utiu+github@gmail.com>
+Nikolay Lazarov <qwerqwerqwer@abv.bg>
+Steve Anton <anxuiz.nx@gmail.com>
+Imran Ahmed Manzoor <imran.manzoor31@gmail.com>
+Ljubiša Moćić <3rdslasher@gmail.com>
+Piotr Korgul <p.korgul@gmail.com>
+Jim Zhang <Hyriodula@gmail.com>
+Sam Sleight <samuel.sleight@gmail.com>
+tborisova <ts.borisova3@gmail.com>
+Chancellor Arkantos <Chancellor_Arkantos@hotmail.co.uk>
+Stepan Simsa <simsa.st@gmail.com>
+Tobias Lenz <t_lenz94@web.de>
+Siddhanathan Shanmugam <siddhanathan@gmail.com>
+Tiffany Zhu <bubble.wubble.303@gmail.com>
+Tristan Hume <tris.hume@gmail.com>
+Alexey Subach <alexey.subach@gmail.com>
+Joan Creus <joan.creus.c@gmail.com>
+Geoffry Song <goffrie@gmail.com>
+Puneeth Chaganti <punchagan@gmail.com>
+Marcin Kostrzewa <>
+Natalia Nawara <fankalemura@gmail.com>
+vishal <vishal.panjwani15@gmail.com>
+Shruti Mangipudi <shruti2395@gmail.com>
+Davy Mao <e_equals_mass_speed_light_squared@hotmail.com>
+Swapnil Agarwal <swapnilag29@gmail.com>
+Dhia Kennouche <kendhia@gmail.com>
+jerryma1121 <jerryma1121@gmail.com>
+Joachim Durchholz <jo@durchholz.org>
+Martin Povišer <martin.povik@gmail.com>
+Siddhant Jain <getsiddhant@gmail.com>
+Kevin Hunter <hunteke@earlham.edu>
+Michael Mayorov <marchael@kb.csu.ru>
+Nathan Alison <nathan.f.alison@gmail.com>
+Christian Bühler <christian@cbuehler.de>
+Carsten Knoll <CarstenKnoll@gmx.de>
+Bharath M R <catchmrbharath@gmail.com>
+Matthias Toews <mat.toews@googlemail.com>
+Sergiu Ivanov <unlimitedscolobb@gmail.com>
+Jorge E. Cardona <jorgeecardona@gmail.com>
+Sanket Agarwal <sanket@sanketagarwal.com>
+Manoj Babu K. <manoj.babu2378@gmail.com>
+Sai Nikhil <tsnlegend@gmail.com>
+Aleksandar Makelov <amakelov@college.harvard.edu>
+Sachin Irukula <sachin.irukula@gmail.com>
+Raphael Michel <webmaster@raphaelmichel.de>
+Ashwini Oruganti <ashwini.oruganti@gmail.com>
+Andreas Klöckner <inform@tiker.net>
+Prateek Papriwal <papriwalprateek@gmail.com>
+Arpit Goyal <agmps18@gmail.com>
+Angadh Nanjangud <angadh.n@gmail.com>
+Comer Duncan <comer.duncan@gmail.com>
+Jens H. Nielsen <jenshnielsen@gmail.com>
+Joseph Dougherty <Github@JWDougherty.com>
+Elliot Marshall <Marshall2389@gmail.com>
+Guru Devanla <grdvnl@gmail.com>
+George Waksman <waksman@gwax.com>
+Alexandr Popov <alexandr.s.popov@gmail.com>
+Tarun Gaba <tarun.gaba7@gmail.com>
+Takafumi Arakaki <aka.tkf@gmail.com>
+Saurabh Jha <saurabh.jhaa@gmail.com>
+Rom le Clair <jacen.guardian@gmail.com>
+Angus Griffith <16sn6uv@gmail.com>
+Timothy Reluga <treluga@math.psu.edu>
+Brian Stephanik <xoedusk@gmail.com>
+Alexander Eberspächer <alex.eberspaecher@gmail.com>
+Sachin Joglekar <srjoglekar246@gmail.com>
+Tyler Pirtle <teeler@gmail.com>
+Vasily Povalyaev <vapovalyaev@gmail.com>
+Colleen Lee <colleenclee@gmail.com>
+Matthew Hoff <mhoff14@gmail.com>
+Niklas Thörne <notrupertthorne@gmail.com>
+Huijun Mai <m.maihuijun@gmail.com>
+Marek Šuppa <mr@shu.io>
+Ramana Venkata <idlike2dream@gmail.com>
+Prasoon Shukla <prasoon92.iitr@gmail.com>
+Stefen Yin <zqyin@ucdavis.edu>
+Thomas Hisch <t.hisch@gmail.com>
+Madeleine Ball <mpball@gmail.com>
+Mary Clark <mary.spriteling@gmail.com>
+Rishabh Dixit <rishabhdixit11@gmail.com>
+Manoj Kumar <manojkumarsivaraj334@gmail.com>
+Akshit Agarwal <akshit.jiit@gmail.com>
+CJ Carey <perimosocordiae@gmail.com>
+Patrick Lacasse <patrick.m.lacasse@gmail.com>
+Ananya H <ananyaha93@gmail.com>
+Tarang Patel <tarangrockr@gmail.com>
+Christopher Dembia <cld72@cornell.edu>
+Benjamin Fishbein <fishbeinb@gmail.com>
+Sean Ge <seange727@gmail.com>
+Amit Jamadagni <bitsjamadagni@gmail.com>
+Ankit Agrawal <aaaagrawal@iitb.ac.in>
+Björn Dahlgren <bjodah@gmail.com>
+Christophe Saint-Jean <christophe.saint-jean@univ-lr.fr>
+Demian Wassermann <demian@bwh.harvard.edu>
+Khagesh Patel <khageshpatel93@gmail.com>
+Stephen Loo <shikil@yahoo.com>
+hm <hacman0@gmail.com>
+Patrick Poitras <acebulf@gmail.com>
+Katja Sophie Hotz <katja.sophie.hotz@student.tuwien.ac.at>
+Varun Joshi <joshi.142@osu.edu>
+Chetna Gupta <cheta.gup@gmail.com>
+Thilina Rathnayake <thilinarmtb@gmail.com>
+Max Hutchinson <maxhutch@gmail.com>
+Shravas K Rao <shravas@gmail.com>
+Matthew Tadd <matt.tadd@gmail.com>
+Alexander Hirzel <alex@hirzel.us>
+Randy Heydon <randy.heydon@clockworklab.net>
+Oliver Lee <oliverzlee@gmail.com>
+Seshagiri Prabhu <seshagiriprabhu@gmail.com>
+Pradyumna <pradyu1993@gmail.com>
+Erik Welch <erik.n.welch@gmail.com>
+Eric Nelson <eric.the.red.XLII@gmail.com>
+Roland Puntaier <roland.puntaier@chello.at>
+Chris Conley <chrisconley15@gmail.com>
+Tim Swast <tswast@gmail.com>
+Dmitry Batkovich <batya239@gmail.com>
+Francesco Bonazzi <franz.bonazzi@gmail.com>
+Yuriy Demidov <iurii.demidov@gmail.com>
+Rick Muller <rpmuller@gmail.com>
+Manish Gill <gill.manish90@gmail.com>
+Markus Müller <markus.mueller.1.g@googlemail.com>
+Amit Saha <amitsaha.in@gmail.com>
+Jeremy <twobitlogic@gmail.com>
+QuaBoo <kisonchristian@gmail.com>
+Stefan van der Walt <stefan@sun.ac.za>
+David Joyner <wdjoyner@gmail.com>
+Lars Buitinck <larsmans@gmail.com>
+Alkiviadis G. Akritas <akritas@uth.gr>
+Vinit Ravishankar <vinit.ravishankar@gmail.com>
+Michael Boyle <michael.oliver.boyle@gmail.com>
+Heiner Kirchhoffer <Heiner.Kirchhoffer@gmail.com>
+Pablo Puente <ppuedom@gmail.com>
+James Fiedler <jrfiedler@gmail.com>
+Harsh Gupta <mail@hargup.in>
+Tuomas Airaksinen <tuomas.airaksinen@gmail.com>
+Paul Strickland <p.e.strickland@gmail.com>
+James Goppert <james.goppert@gmail.com>
+rathmann <rathmann.os@gmail.com>
+Avichal Dayal <avichal.dayal@gmail.com>
+Paul Scott <paul.scott@nicta.com.au>
+Shipra Banga <bangashipra@gmail.com>
+Pramod Ch <pramodch14@gmail.com>
+Akshay <akshaynukala95@gmail.com>
+Buck Shlegeris <buck2@bruceh15.anu.edu.au>
+Jonathan Miller <jdmiller93@gmail.com>
+Edward Schembor <eschemb1@jhu.edu>
+Rajath Shashidhara <rajaths.rajaths@gmail.com>
+Zamrath Nizam <zamiguy_ni@yahoo.com>
+Aditya Shah <adityashah30@gmail.com>
+Rajat Aggarwal <rajataggarwal1975@gmail.com>
+Sambuddha Basu <sammygamer@live.com>
+Zeel Shah <kshah215@gmail.com>
+Abhinav Chanda <abhinavchanda01@gmail.com>
+Jim Crist <crist042@umn.edu>
+Sudhanshu Mishra <mrsud94@gmail.com>
+Anurag Sharma <anurags92@gmail.com>
+Soumya Dipta Biswas <sdb1323@gmail.com>
+Sushant Hiray <hiraysushant@gmail.com>
+Ben Lucato <ben.lucato@gmail.com>
+Kunal Arora <kunalarora.135@gmail.com>
+Henry Gebhardt <hsggebhardt@gmail.com>
+Dammina Sahabandu <dmsahabandu@gmail.com>
+Manish Shukla <manish.shukla393@gmail>
+Ralph Bean <rbean@redhat.com>
+richierichrawr <richierichrawr@users.noreply.github.com>
+John Connor <john.theman.connor@gmail.com>
+Juan Luis Cano Rodríguez <juanlu001@gmail.com>
+Sahil Shekhawat <sahilshekhawat01@gmail.com>
+Kundan Kumar <kundankumar18581@gmail.com>
+Stas Kelvich <stanconn@gmail.com>
+sevaader <sevaader@gmail.com>
+Dhruvesh Vijay Parikh <parikhdhruvesh1@gmail.com>
+Venkatesh Halli <venkatesh.fatality@gmail.com>
+Lennart Fricke <lennart@die-frickes.eu>
+Vlad Seghete <vlad.seghete@gmail.com>
+Shashank Agarwal <shashank.agarwal94@gmail.com>
+carstimon <carstimon@gmail.com>
+Pierre Haessig <pierre.haessig@crans.org>
+Maciej Baranski <getrox.sc@gmail.com>
+Benjamin Gudehus <hastebrot@gmail.com>
+Faisal Anees <faisal.iiit@gmail.com>
+Mark Shoulson <mark@kli.org>
+Robert Johansson <jrjohansson@gmail.com>
+Kalevi Suominen <jksuom@gmail.com>
+Kaushik Varanasi <kaushik.varanasi1@gmail.com>
+Fawaz Alazemi <Mba7eth@gmail.com>
+Ambar Mehrotra <mehrotraambar@gmail.com>
+David P. Sanders <dpsanders@gmail.com>
+Peter Brady <petertbrady@gmail.com>
+John V. Siratt <jvsiratt@gmail.com>
+Sarwar Chahal <chahal.sarwar98@gmail.com>
+Nathan Woods <charlesnwoods@gmail.com>
+Colin B. Macdonald <cbm@m.fsf.org>
+Marcus Näslund <naslundx@gmail.com>
+Clemens Novak <clemens@familie-novak.net>
+Mridul Seth <seth.mridul@gmail.com>
+Craig A. Stoudt <craig.stoudt@gmail.com>
+Raj <raj454raj@gmail.com>
+Mihai A. Ionescu <ionescu.a.mihai@gmail.com>
+immerrr <immerrr@gmail.com>
+Chai Wah Wu <cwwuieee@gmail.com>
+Leonid Blouvshtein <leonidbl91@gmail.com>
+Peleg Michaeli <freepeleg@gmail.com>
+ck Lux <lux.r.ck@gmail.com>
+zsc347 <zsc347@gmail.com>
+Hamish Dickson <hamish.dickson@gmail.com>
+Michael Gallaspy <gallaspy.michael@gmail.com>
+Roman Inflianskas <infroma@gmail.com>
+Duane Nykamp <nykamp@umn.edu>
+Ted Dokos <tdokos@gmail.com>
+Sunny Aggarwal <sunnyaggarwal1994@gmail.com>
+Victor Brebenar <v.brebenar@gmail.com>
+Akshat Jain <akshat.jain@students.iiit.ac.in>
+Shivam Vats <shivamvats.iitkgp@gmail.com>
+Longqi Wang <iqgnol@gmail.com>
+Juan Felipe Osorio <jfosorio@gmail.com>
+Ray Cathcart <github@cathcart.us>
+Lukas Zorich <lukas.zorich@gmail.com>
+Eric Miller <emiller42@gmail.com>
+Cody Herbst <cyherbst@gmail.com>
+Nishith Shah <nishithshah.2211@gmail.com>
+Amit Kumar <dtu.amit@gmail.com>
+Yury G. Kudryashov <urkud.urkud@gmail.com>
+Guillaume Gay <contact@damcb.com>
+Mihir Wadwekar <m.mihirw@gmail.com>
+Tuan Manh Lai <laituan245@gmail.com>
+Asish Panda <asishrocks95@gmail.com>
+Darshan Chaudhary <deathbullet@gmail.com>
+Alec Kalinin <alec.kalinin@gmail.com>
+Ralf Stephan <ralf@ark.in-berlin.de>
+Aaditya Nair <aadityanair6494@gmail.com>
+Jayesh Lahori <jlahori92@gmail.com>
+Harshil Goel <harshil158@gmail.com>
+Luv Agarwal <agarwal.iiit@gmail.com>
+Jason Ly <jason.ly@gmail.com>
+Lokesh Sharma <lokeshhsharma@gmail.com>
+Sartaj Singh <singhsartaj94@gmail.com>
+Chris Swierczewski <cswiercz@gmail.com>
+Konstantin Togoi <konstantin.togoi@gmail.com>
+Param Singh <paramsingh258@gmail.com>
+Sumith Kulal <sumith1896@gmail.com>
+Juha Remes <jremes@outlook.com>
+Philippe Bouafia <philippe.bouafia@ensea.fr>
+Peter Schmidt <peter@peterjs.com>
+Jiaxing Liang <liangjiaxing57@gmail.com>
+Lucas Jones <lucas@lucasjones.co.uk>
+Gregory Ashton <gash789@gmail.com>
+Jennifer White <jcrw122@googlemail.com>
+Renato Orsino <renato.orsino@gmail.com>
+Alistair Lynn <arplynn@gmail.com>
+Govind Sahai <gsiitbhu@gmail.com>
+Adam Bloomston <adam@glitterfram.es>
+Kyle McDaniel <mcdanie5@illinois.edu>
+Nguyen Truong Duy <truongduy134@yahoo.com>
+Alex Lindsay <adlinds3@ncsu.edu>
+Mathew Chong <mathewchong.dev@gmail.com>
+Jason Siefken <siefkenj@gmail.com>
+Gaurav Dhingra <gauravdhingra.gxyd@gmail.com>
+Gao, Xiang <qasdfgtyuiop@gmail.com>
+Kevin Ventullo <kevin.ventullo@gmail.com>
+mao8 <thisisma08@gmail.com>
+Isuru Fernando <isuruf@gmail.com>
+Shivam Tyagi <shivam.tyagi.apm13@itbhu.ac.in>
+Richard Otis <richard.otis@outlook.com>
+Rich LaSota <rjlasota@gmail.com>
+dustyrockpyle <dustyrockpyle@gmail.com>
+Anton Akhmerov <anton.akhmerov@gmail.com>
+Michael Zingale <michael.zingale@stonybrook.edu>
+Chak-Pong Chung <chakpongchung@gmail.com>
+David T <derDavidT@users.noreply.github.com>
+Phil Ruffwind <rf@rufflewind.com>
+Sebastian Koslowski <koslowski@kit.edu>
+Kumar Krishna Agrawal <kumar.1994.14@gmail.com>
+Dustin Gadal <Dustin.Gadal@gmail.com>
+João Moura <operte@gmail.com>
+Yu Kobayashi <yukoba@accelart.jp>
+Shashank Kumar <shashank.kumar.apc13@iitbhu.ac.in>
+Timothy Cyrus <tcyrus@users.noreply.github.com>
+Devyani Kota <devyanikota@gmail.com>
+Keval Shah <kevalshah_96@yahoo.co.in>
+Dzhelil Rufat <drufat@caltech.edu>
+Pastafarianist <mr.pastafarianist@gmail.com>
+Sourav Singh <souravsingh@users.noreply.github.com>
+Jacob Garber <jgarber1@ualberta.ca>
+Vinay Singh <csvinay.d@gmail.com>
+GolimarOurHero <metalera94@hotmail.com>
+Prashant Tyagi <prashanttyagi221295@gmail.com>
+Matthew Davis <davisml.md@gmail.com>
+Tschijnmo TSCHAU <tschijnmotschau@gmail.com>
+Alexander Bentkamp <bentkamp@gmail.com>
+Jack Kemp <metaknightdrake-git@yahoo.co.uk>
+Kshitij Saraogi <KshitijSaraogi@gmail.com>
+Thomas Baruchel <baruchel@gmx.com>
+Nicolás Guarín-Zapata <nicoguarin@gmail.com>
+Jens Jørgen Mortensen <jj@smoerhul.dk>
+Sampad Kumar Saha <sampadsaha5@gmail.com>
+Eva Charlotte Mayer <eva-charlotte.mayer@posteo.de>
+Laura Domine <temigo@gmx.com>
+Justin Blythe <jblythe29@gmail.com>
+Meghana Madhyastha <meghana.madhyastha@gmail.com>
+Tanu Hari Dixit <tokencolour@gmail.com>
+Shekhar Prasad Rajak <shekharrajak@live.com>
+Aqnouch Mohammed <aqnouch.mohammed@gmail.com>
+Arafat Dad Khan <arafat.da.khan@gmail.com>
+Boris Atamanovskiy <shaomoron@gmail.com>
+Sam Tygier <sam.tygier@hep.manchester.ac.uk>
+Jai Luthra <me@jailuthra.in>
+Guo Xingjian <Seeker1995@gmail.com>
+Sandeep Veethu <sandeep.veethu@gmail.com>
+Archit Verma <architv07@gmail.com>
+Shubham Tibra <shubh.tibra@gmail.com>
+Ashutosh Saboo <ashutosh.saboo96@gmail.com>
+Michael S. Hansen <michael.hansen@nih.gov>
+Anish Shah <shah.anish07@gmail.com>
+Guillaume Jacquenot <guillaume.jacquenot@gmail.com>
+Bhautik Mavani <mavanibhautik@gmail.com>
+Michał Radwański <enedil.isildur@gmail.com>
+Jerry Li <jerry@jerryli.ca>
+Pablo Zubieta <pabloferz@yahoo.com.mx>
+Shivam Agarwal <knowthyself2503@gmail.com>
+Chaitanya Sai Alaparthi <achaitanyasai@gmail.com>
+Arihant Parsoya <parsoyaarihant@gmail.com>
+Ruslan Pisarev <rpisarev@cloudlinux.com>
+Akash Trehan <akash.trehan123@gmail.com>
+Nishant Nikhil <nishantiam@gmail.com>
+Vladimir Poluhsin <vovapolu@gmail.com>
+Akshay Nagar <awesomeay13@yahoo.com>
+James Brandon Milam <jmilam343@gmail.com>
+Abhinav Agarwal <abhinavagarwal1996@gmail.com>
+Rishabh Daal <rishabhdaal@gmail.com>
+Sanya Khurana <sanya@monica.in>
+Aman Deep <amandeep1024@gmail.com>
+Aravind Reddy <aravindreddy255@gmail.com>
+Abhishek Verma <iamvermaabhishek@gmail.com>
+Matthew Parnell <matt@parnmatt.co.uk>
+Thomas Hickman <Thomas.Hickman42@gmail.com>
+Akshay Siramdas <akshaysiramdas@gmail.com>
+YiDing Jiang <yidinggjiangg@gmail.com>
+Jatin Yadav <jatinyadav25@gmail.com>
+Matthew Thomas <mnmt@users.noreply.github.com>
+Rehas Sachdeva <aquannie@gmail.com>
+Michael Mueller <michaeldmueller7@gmail.com>
+Srajan Garg <srajan.garg@gmail.com>
+Prabhjot Singh <prabhjot.nith@gmail.com>
+Haruki Moriguchi <harukimoriguchi@gmail.com>
+Tom Gijselinck <tomgijselinck@gmail.com>
+Nitin Chaudhary <nitinmax1000@gmail.com>
+Alex Argunov <sajkoooo@gmail.com>
+Nathan Musoke <nathan.musoke@gmail.com>
+Abhishek Garg <abhishekgarg119@gmail.com>
+Dana Jacobsen <dana@acm.org>
+Vasiliy Dommes <vasdommes@gmail.com>
+Phillip Berndt <phillip.berndt@googlemail.com>
+Haimo Zhang <zh.hammer.dev@gmail.com>
+Anthony Scopatz <scopatz@gmail.com>
+bluebrook <perl4logic@gmail.com>
+Leonid Kovalev <leonidvkovalev@gmail.com>
+Josh Burkart <jburkart@gmail.com>
+Dimitra Konomi <t8130064@dias.aueb.gr>
+Christina Zografou <t8130048@dias.aueb.gr>
+Fiach Antaw <fiach.antaw+github@gmail.com>
+Langston Barrett <langston.barrett@gmail.com>
+Krit Karan <kritkaran.b13@iiits.in>
+G. D. McBain <gdmcbain@protonmail.com>
+Prempal Singh <prempal.42@gmail.com>
+Gabriel Orisaka <orisaka@gmail.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com>
+rahuldan <rahul02013@gmail.com>
+Colin Marquardt <github@marquardt-home.de>
+Andrew Taber <andrew.e.taber@gmail.com>
+Yash Reddy <write2yashreddy@gmail.com>
+Peter Stangl <peter.stangl@ph.tum.de>
+elvis-sik <e.sikora@grad.ufsc.br>
+Nikos Karagiannakis <nikoskaragiannakis@gmail.com>
+Jainul Vaghasia <jainulvaghasia@gmail.com>
+Dennis Meckel <meckel@datenschuppen.de>
+Harshil Meena <harshil.7535@gmail.com>
+Micky <mickydroch@gmail.com>
+Nick Curtis <nicholas.curtis@uconn.edu>
+Michele Zaffalon <michele.zaffalon@gmail.com>
+Martha Giannoudovardi <maapxa@gmail.com>
+Devang Kulshreshtha <devang.kulshreshtha.cse14@itbhu.ac.in>
+Steph Papanik <spapanik21@gmail.com>
+Mohammad Sadeq Dousti <msdousti@gmail.com>
+Arif Ahmed <arif.ahmed.5.10.1995@gmail.com>
+Abdullah Javed Nesar <abduljaved1994@gmail.com>
+Lakshya Agrawal <zeeshan.lakshya@gmail.com>
+shruti <shrutishrm512@gmail.com>
+Rohit Rango <rohit.rango@gmail.com>
+Hong Xu <hong@topbug.net>
+Ivan Petuhov <ivan@ostrovok.ru>
+Alsheh <alsheh@rpi.edu>
+Marcel Stimberg <marcel.stimberg@ens.fr>
+Alexey Pakhocmhik <cool.Bakov@yandex.ru>
+Tommy Olofsson <tommy.olofsson.90@gmail.com>
+Zulfikar <zulfikar97@gmail.com>
+Blair Azzopardi <blairuk@gmail.com>
+Danny Hermes <daniel.j.hermes@gmail.com>
+Sergey Pestov <pestov-sa@yandex.ru>
+Mohit Chandra <mohit.chandra@research.iiit.ac.in>
+Karthik Chintapalli <karthik.chintapalli@students.iiit.ac.in>
+Marcin Briański <marcin.brianski@student.uj.edu.pl>
+andreo <andrey.torba@gmail.com>
+Flamy Owl <flamyowl@protonmail.ch>
+Yicong Guo <guoyicong100@gmail.com>
+Varun Garg <varun.garg03@gmail.com>
+Rishabh Madan <rishabhmadan96@gmail.com>
+Aditya Kapoor <aditya.kapoor.apm12@itbhu.ac.in>
+Karan Sharma <karan1276@gmail.com>
+Vedant Rathore <vedantr1998@gmail.com>
+Johan Blåbäck <johan_bluecreek@riseup.net>
+Pranjal Tale <pranjaltale16@gmail.com>
+Jason Tokayer <jason.tokayer@gmail.com>
+Raghav Jajodia <jajodia.raghav@gmail.com>
+Rajat Thakur <rajatthakur1997@gmail.com>
+Dhruv Bhanushali <dhruv_b@live.com>
+Anjul Kumar Tyagi <anjul.ten@gmail.com>
+Barun Parruck <barun.parruck@gmail.com>
+Bao Chau <chauquocbao0907@gmail.com>
+Tanay Agrawal <tanay_agrawal@hotmail.com>
+Ranjith Kumar <ranjith.dakshana2015@gmail.com>
+Shikhar Makhija <shikharmakhija2@gmail.com>
+Yathartha Joshi <yathartha32@gmail.com>
+Valeriia Gladkova <valeriia.gladkova@gmail.com>
+Sagar Bharadwaj <sagarbharadwaj50@gmail.com>
+Daniel Mahler <dmahler@gmail.com>
+Ka Yi <chua.kayi@yahoo.com.sg>
+Rishat Iskhakov <iskhakov@frtk.ru>
+Szymon Mieszczak <szymon.mieszczak@gmail.com>
+Sachin Agarwal <sachinagarwal0499@gmail.com>
+Priyank Patel <pspbot7@gmail.com>
+Satya Prakash Dwibedi <akash581050@gmail.com>
+tools4origins <tools4origins@gmail.com>
+Nico Schlömer <nico.schloemer@gmail.com>
+Fermi Paradox <FermiParadox@users.noreply.github.com>
+Ekansh Purohit <purohit.e15@gmail.com>
+Vedarth Sharma <vedarth.sharma@gmail.com>
+Peeyush Kushwaha <peeyush.p97@gmail.com>
+Jayjayyy <vfhsln8s3l4b87t4c3@byom.de>
+Christopher J. Wright <cjwright4242gh@gmail.com>
+Jakub Wilk <jwilk@jwilk.net>
+Mauro Garavello <mauro.garavello@unimib.it>
+Chris Tefer <ctefer@gmail.com>
+Shikhar Jaiswal <jaiswalshikhar87@gmail.com>
+Chiu-Hsiang Hsu <wdv4758h@gmail.com>
+Carlos Cordoba <ccordoba12@gmail.com>
+Fabian Ball <fabian.ball@kit.edu>
+Yerniyaz <yerniyaz.nurgabylov@nu.edu.kz>
+Christiano Anderson <canderson@riseup.net>
+Robin Neatherway <robin.neatherway@gmail.com>
+Thomas Hunt <thomashunt13@gmail.com>
+Theodore Han <theodorehan@hotmail.com>
+Duc-Minh Phan <alephvn@gmail.com>
+Lejla Metohajrova <l.metohajrova@gmail.com>
+Samyak Jain <samyak.jain2016a@vitstudent.ac.in>
+Aditya Rohan <riyuzakiiitk@gmail.com>
+Vincent Delecroix <vincent.delecroix@labri.fr>
+Michael Sparapany <msparapa@purdue.edu>
+Harsh Jain <harshjniitr@gmail.com>
+Nathan Goldbaum <ngoldbau@illinois.edu>
+latot <felipematas@yahoo.com>
+Kenneth Lyons <ixjlyons@gmail.com>
+Stan Schymanski <stan.schymanski@env.ethz.ch>
+David Daly <david.daly12@kzoo.edu>
+Ayush Shridhar <ayush.shridhar1999@gmail.com>
+Javed Nissar <javednissar@gmail.com>
+Jiri Kuncar <jiri.kuncar@gmail.com>
+vedantc98 <vedantc98@gmail.com>
+Rupesh Harode <rupeshharode@gmail.com>
+Rob Zinkov <rob@zinkov.com>
+James Harrop <ebc121@gmail.com>
+James Taylor <user234683@tutanota.com>
+Ishan Joshi <ishanaj98@gmail.com>
+Marco Mancini <marco.mancini@obspm.fr>
+Boris Ettinger <ettinger.boris@gmail.com>
+Micah Fitch <micahscopes@gmail.com>
+Daniel Wennberg <daniel.wennberg@gmail.com>
+ylemkimon <ylemkimon@naver.com>
+Akash Vaish <akash.9712@gmail.com>
+Peter Enenkel <peter.enenkel+git@gmail.com>
+Waldir Pimenta <waldyrious@gmail.com>
+Jithin D. George <jithindgeorge93@gmail.com>
+Lev Chelyadinov <leva181777@gmail.com>
+Lucas Wiman <lucas.wiman@gmail.com>
+Rhea Parekh <rheaparekh12@gmail.com>
+James Cotton <peabody124@gmail.com>
+Robert Pollak <robert.pollak@posteo.net>
+anca-mc <anca-mc@users.noreply.github.com>
+Sourav Ghosh <souravghosh2197@gmail.com>
+Jonathan Allan <jjallan@users.noreply.github.com>
+Nikhil Pappu <nkhlpappu@gmail.com>
+Ethan Ward <etkewa@gmail.com>
+Cezary Marczak <zeddq1@gmail.com>
+dps7ud <dps7ud@virginia.edu>
+Nilabja Bhattacharya <nilabja10201992@gmail.com>
+Itay4 <31018228+Itay4@users.noreply.github.com>
+Poom Chiarawongse <eight1911@gmail.com>
+Yang Yang <wdscxsj@gmail.com>
+Cavendish McKay <cmckay@tachycline.com>
+Bradley Gannon <bradley.m.gannon@gmail.com>
+B McG <bmcg0890@gmail.com>
+Rob Drynkin <rob.drynkin@gmail.com>
+Seth Ebner <murgrehk@gmail.com>
+Akash Kundu <sk.sayakkundu1997@gmail.com>
+Mark Jeromin <mark.jeromin@sysfrog.net>
+Roberto Díaz Pérez <r.r.1994a@gmail.com>
+Gleb Siroki <g.shiroki@gmail.com>
+Segev Finer <segev208@gmail.com>
+Alex Lubbock <code@alexlubbock.com>
+Ayodeji Ige <ayodeji18@outlook.com>
+Matthew Wardrop <matthew.wardrop@airbnb.com>
+Hugo van Kemenade <hugovk@users.noreply.github.com>
+Austin Palmer <ap4000@nyu.edu>
+der-blaue-elefant <github@kklein.de>
+Filip Gokstorp <filip@gokstorp.se>
+Yuki Matsuda <yuki.matsuda.w@gmail.com>
+Aaron Miller <acmiller273@gmail.com>
+Salil Vishnu Kapur <salilvishnukapur@gmail.com>
+Atharva Khare <khareatharva@gmail.com>
+Shubham Maheshwari <rmaheshwari05@gmail.com>
+Pavel Tkachenko <paveltkachenko@email.com>
+Ashish Kumar Gaurav <ashishkg0022@gmail.com>
+Rajeev Singh <rajs2010@gmail.com>
+Keno Goertz <keno@goertz-berlin.com>
+Lucas Gallindo <lgallindo@gmail.com>
+Himanshu <hs80941@gmail.com>
+David Menéndez Hurtado <david.menendez.hurtado@scilifelab.se>
+Amit Manchanda <amitdelhi1995@gmail.com>
+Rohit Jain <rohitjain3241@gmail.com>
+Jonathan A. Gross <jarthurgross@gmail.com>
+Unknown <kunda@scribus.net>
+Sayan Goswami <Sayan98@users.noreply.github.com>
+Subhash Saurabh <subhashsaurabh419@gmail.com>
+Rastislav Rabatin <rastislav.rabatin@gmail.com>
+Vishal <vishalg2235@gmail.com>
+Jeremey Gluck <jeremygluck@yahoo.com>
+Akshat Maheshwari <akshat14714@gmail.com>
+symbolique <symbolique@users.noreply.github.com>
+Saloni Jain <tosalonijain@gmail.com>
+Arighna Chakrabarty <arighna.chakrabarty100@gmail.com>
+Abhigyan Khaund <mail@abhigyan.xyz>
+Jashanpreet Singh <jashansingh.4398@gmail.com>
+Saurabh Agarwal <shourabh.agarwal@gmail.com>
+luzpaz <luzpaz@users.noreply.github.com>
+P. Sai Prasanth <psai.prasanth.min16@itbhu.ac.in>
+Nirmal Sarswat <nirmalsarswat400@gmail.com>
+Cristian Di Pietrantonio <cristiandipietrantonio@gmail.com>
+Ravi charan <ravicharan.vsp@gmail.com>
+Nityananda Gohain <nityanandagohain@gmail.com>
+Cédric Travelletti <cedrictravelletti@gmail.com>
+Nicholas Bollweg <nick.bollweg@gmail.com>
+Himanshu Ladia <hladia199811@gmail.com>
+Adwait Baokar <adwaitbaokar18@gmail.com>
+Mihail Tarigradschi <m.tarigradschi@gmail.com>
+Saketh <alurusaisaketh@gmail.com>
+rushyam <rushyamsonu@gmail.com>
+sfoo <sfoohei@gmail.com>
+Rahil Hastu <rahilhastu@gmail.com>
+Zach Raines <raineszm@gmail.com>
+Sidhant Nagpal <sidhantnagpal97@gmail.com>
+Gagandeep Singh <singh.23@iitj.ac.in>
+Rishav Chakraborty <annonymousxyz@outlook.com>
+Malkhan Singh <malkhansinghrathaur@gmail.com>
+Joaquim Monserrat <qmonserrat@mailoo.org>
+Mayank Singh <mayank.singh081997@gmail.com>
+Rémy Léone <rleone@online.net>
+Maxence Mayrand <35958639+maxencemayrand@users.noreply.github.com>
+Nikoleta Glynatsi <GlynatsiNE@cardiff.ac.uk>
+helo9 <helo9@users.noreply.github.com>
+Ken Wakita <wakita@is.titech.ac.jp>
+Carl Sandrock <carl.sandrock@up.ac.za>
+Fredrik Eriksson <freeriks@student.chalmers.se>
+Ian Swire <oversizedpenguin@gmail.com>
+Bulat <daianovich@mail.ru>
+Ehren Metcalfe <ehren.m@gmail.com>
+Dmitry Savransky <dsavransky@gmail.com>
+Kiyohito Yamazaki <kyamaz@openql.org>
+Caley Finn <caleyreuben@gmail.com>
+Zhi-Qiang Zhou <zzq_890709@hotmail.com>
+Alexander Pozdneev <pozdneev@users.noreply.github.com>
+Wes Turner <50891+westurner@users.noreply.github.com>
+JMSS-Unknown <31131631+JMSS-Unknown@users.noreply.github.com>
+Arshdeep Singh <singh.arshdeep1999@gmail.com>
+cym1 <16437732+cym1@users.noreply.github.com>
+Stewart Wadsworth <stewart.wadsworth@gmail.com>
+Jared Lumpe <mjlumpe@gmail.com>
+Avi Shrivastava <shrivastavaavi123@gmail.com>
+ramvenkat98 <ramvenkat98@gmail.com>
+Bilal Ahmed <b.ahmed0918@gmail.com>
+Dimas Abreu Archanjo Dutra <dimasad@ufmg.br>
+Yatna Verma <yatnavermaa@gmail.com>
+S.Y. Lee <sylee957@gmail.com>
+Miro Hrončok <miro@hroncok.cz>
+Sudarshan Kamath <sudarshan.kamath97@gmail.com>
+Ayushman Koul <ayushmankoul4570@gmail.com>
+Robert Dougherty-Bliss <robert.w.bliss@gmail.com>
+Andrey Grozin <A.G.Grozin@inp.nsk.su>
+Bavish Kulur <bavishkulur@gmail.com>
+Arun Singh <arunsin997@gmail.com>
+sirnicolaf <43586954+sirnicolaf@users.noreply.github.com>
+Zachariah Etienne <zachetie@gmail.com>
+Prayush Dawda <35144226+iamprayush@users.noreply.github.com>
+2torus <boris.ettinger@gmail.com>
+Faisal Riyaz <faisalriyaz011@gmail.com>
+Martin Roelfs <u0114255@kuleuven.be>
+SirJohnFranklin <sirjfu@googlemail.com>
+Anthony Sottile <asottile@umich.edu>
+ViacheslavP <public.viacheslav@gmail.com>
+Safiya03 <safiyanesar@gmail.com>
+Alexander Dunlap <alexander.dunlap@gmail.com>
+Rohit Sharma <31184621+rohitx007@users.noreply.github.com>
+Jonathan Warner <warnerjon12@gmail.com>
+Mohit Balwani <mohitbalwani.ict17@gmail.com>
+Marduk Bolaños <mardukbp@mac.com>
+amsuhane <ayushsuhane99@iitkgp.ac.in>
+Matthias Geier <Matthias.Geier@gmail.com>
+klaasvanaarsen <44929042+klaasvanaarsen@users.noreply.github.com>
+Shubham Kumar Jha <skjha832@gmail.com>
+rationa-kunal <kunalgk1999@gmail.com>
+Animesh Sinha <animeshsinha1309@gmail.com>
+Gaurang Tandon <1gaurangtandon@gmail.com>
+Matthew Craven <clyring@users.noreply.github.com>
+Daniel Ingram <ingramds@appstate.edu>
+Jogi Miglani <jmig5776@gmail.com>
+Takumasa Nakamura <n.takumasa@gmail.com>
+Ritu Raj Singh <RituRajSingh878@gmail.com>
+Rajiv Ranjan Singh <rajivperfect007@gmail.com>
+Vera Lozhkina <veralozhkina@gmail.com>
+adhoc-king <46354827+adhoc-king@users.noreply.github.com>
+Mikel Rouco <mikel.mrm@gmail.com>
+Oscar Gustafsson <oscar.gustafsson@gmail.com>
+damianos <damianos@semmle.com>
+Supreet Agrawal <supreet11agrawal@gmail.com>
+shiksha11 <shiksharawat01@gmail.com>
+Martin Ueding <dev@martin-ueding.de>
+sharma-kunal <kunalsharma6914@gmail.com>
+Divyanshu Thakur <divyanshu@iiitmanipur.ac.in>
+Susumu Ishizuka <susumu.ishizuka@kii.com>
+Samnan Rahee <namanush.rsr.16@gmail.com>
+Fredrik Andersson <fredrik.andersson@fcc.chalmers.se>
+Bhavya Srivastava <bhavya17037@iiitd.ac.in>
+Alpesh Jamgade <alpeshjamgade21@gmail.com>
+Shubham Abhang <shubhamabhang77@gmail.com>
+Vishesh Mangla <manglavishesh64@gmail.com>
+Nicko van Someren <nicko@nicko.org>
+dandiez <47832466+dandiez@users.noreply.github.com>
+Frédéric Chapoton <fchapoton2@gmail.com>
+jhanwar <f2015463@pilani.bits-pilani.ac.in>
+Noumbissi valere Gille Geovan <noumbissivalere@gmail.com>
+Salmista-94 <alejandrogroso@hotmail.com>
+Shivani Kohli <shivanikohli.09@gmail.com>
+Parker Berry <parkereberry@gmail.com>
+Pragyan Mehrotra <pragyan18168@iiitd.ac.in>
+Nabanita Dash <dashnabanita@gmail.com>
+Gaetano Guerriero <x.guerriero@tin.it>
+Ankit Raj Pandey <pandeyan@grinnell.edu>
+Ritesh Kumar <ritesh99rakesh@gmail.com>
+kangzhiq <709563092@qq.com>
+Jun Lin <junlin0604@gmail.com>
+Petr Kungurtsev <corwinat@gmail.com>
+Anway De <anway1756@gmail.com>
+znxftw <vishnu2101@gmail.com>
+Denis Ivanenko <ivanenko@ucu.edu.ua>
+Orestis Vaggelis <orestisvaggelis@mail.com>
+Nikhil Maan <nikhilmaan22@gmail.com>
+Abhinav Anand <abhinav.anand2807@gmail.com>
+Qingsha Shi <googol.sqs@gmail.com>
+Juan Barbosa <js.barbosa10@uniandes.edu.co>
+Prionti Nasir <pdn3628@rit.edu>
+Bharat Raghunathan <bharatraghunthan9767@gmail.com>
+arooshiverma <av22@iitbbs.ac.in>
+Christoph Gohle <ctg@mpq.mpg.de>
+Charalampos Tsiagkalis <ctsiagkalis@uth.gr>
+Daniel Sears <highpost@users.noreply.github.com>
+Megan Ly <megan.ly@learnosity.com>
+Sean P. Cornelius <spcornelius@gmail.com>
+Erik R. Gomez <gomez@kth.se>
+Riccardo Magliocchetti <riccardo.magliocchetti@gmail.com>
+Henry Metlov <genrih.metlov@gmail.com>
+pekochun <hamburg_hamburger2000@yahoo.co.jp>
+Bendik Samseth <b.samseth@gmail.com>
+Vighnesh Shenoy <vighneshq@gmail.com>
+Versus Void <versusvoid@gmail.com>
+Denys Rybalka <rybalka.denis@gmail.com>
+Mark Dickinson <dickinsm@gmail.com>
+Rimi <rimibis@umich.edu>
+rimibis <33387803+rimibis@users.noreply.github.com>
+Steven Lee <stevenlee123@protonmail.com>
+Gilles Schintgen <gschintgen@hambier.lu>
+Abhi58 <abhijithbharadwaj58@gmail.com>
+Tomasz Pytel <tompytel@gmail.com>
+Aadit Kamat <aadit.k12@gmail.com>
+Samesh <samesh.lakhotia@gmail.com>
+Velibor Zeli <velibor@mech.kth.se>
+Gabriel Bernardino <gabriel.bernardino@upf.edu>
+Joseph Redfern <joseph@redfern.me>
+Evelyn King <evelyn.cameron.king@gmail.com>
+Miguel Marco <mmarco@unizar.es>
+David Hagen <david@drhagen.com>
+Hannah Kari <hannah.kari@marquette.edu>
+Soniya Nayak <soniyanayak51@gmail.com>
+Harsh Agarwal <hagarwal9200@gmail.com>
+Enric Florit <efz1005@gmail.com>
+Yogesh Mishra <ymishra013@gmail.com>
+Denis Rykov <rykovd@gmail.com>
+Ivan Tkachenko <me@ratijas.tk>
+Kenneth Emeka Odoh <kenneth.odoh@gmail.com>
+Stephan Seitz <stephan.seitz@fau.de>
+Yeshwanth N <yeshsurya@gmail.com>
+Oscar Gerardo Lazo Arjona <oscar.lazoarjona@physics.ox.ac.uk>
+Srinivasa Arun Yeragudipati <ysarun1999@gmail.com>
+Kirtan Mali <kirtanmali555@gmail.com>
+TitanSnow <sweeto@live.cn>
+Pengning Chao <8857165+PengningChao@users.noreply.github.com>
+Louis Abraham <louis.abraham@yahoo.fr>
+Morten Olsen Lysgaard <morten@lysgaard.no>
+Akash Nagaraj (akasnaga) <akasnaga@cisco.com>
+Akash Nagaraj <grassknoted@gmail.com>
+Lauren Glattly <laurenglattly@gmail.com>
+Hou-Rui <houruinus@gmail.com>
+George Korepanov <gkorepanov.gk@gmail.com>
+dranknight09 <cbhaavan@gmail.com>
+aditisingh2362 <aditisingh2362@gmail.com>
+Gina <Dr-G@users.noreply.github.com>
+gregmedlock <gmedlo@gmail.com>
+Georgios Giapitzakis Tzintanos <giorgosgiapis@mail.com>
+Eric Wieser <wieser.eric@gmail.com>
+Bradley Dowling <34559056+btdow@users.noreply.github.com>
+Maria Marginean <33810762+mmargin@users.noreply.github.com>
+Akash Agrawall <akash.wanted@gmail.com>
+jgulian <josephdgulian@gmail.com>
+Sourav Goyal <souravgl0@gmail.com>
+Zlatan Vasović <zlatanvasovic@gmail.com>
+Alex Meiburg <timeroot.alex@gmail.com>
+Smit Lunagariya <smitlunagariya.mat18@itbhu.ac.in>
+Naman Gera <namangera15@gmail.com>
+Julien Palard <julien@palard.fr>
+Dhruv Mendiratta <dhruvmendiratta6@gmail.com>
+erdOne <36414270+erdOne@users.noreply.github.com>
+risubaba <risubhjain1010@gmail.com>
+abhinav28071999 <41710346+abhinav28071999@users.noreply.github.com>
+Jisoo Song <jeesoo9595@snu.ac.kr>
+Jaime R <38530589+Jaime02@users.noreply.github.com>
+Vikrant Malik <vikrantmalik051@gmail.com>
+Hardik Saini <43683678+Guardianofgotham@users.noreply.github.com>
+Abhishek <uchiha@pop-os.localdomain>
+Johannes Hartung <joha2@gmx.net>
+Milan Jolly <milan.cs16@iitp.ac.in>
+faizan2700 <syedfaizan824@gmail.com>
+mohit <39158356+mohitacecode@users.noreply.github.com>
+Mohit Gupta <mohitgupta@gmail.com>
+Psycho-Pirate <prakharsaxena.civ18@iitbhu.ac.in>
+Chanakya-Ekbote <ca10@iitbbs.ac.in>
+Rashmi Shehana <rashmi.watagedara@syscolabs.com>
+Jonty16117 <jonty@DESKTOP-J1O6ANP.localdomain>
+Anubhav Gupta <anubhav.gupta.cse19@itbhu.ac.in>
+Michal Grňo <m93a.cz@gmail.com>
+vezeli <37907135+vezeli@users.noreply.github.com>
+Tim Gates <tim.gates@iress.com>
+Sandeep Murthy <smurthy@protonmail.ch>
+Neil <mistersheik@gmail.com>
+V1krant <46847915+V1krant@users.noreply.github.com>
+alejandro <amartinhernan@gmail.com>
+Riyan Dhiman <Riyandhiman14@gmail.com>
+sbt4104 <sthorat661@gmail.com>
+Seth Troisi <sethtroisi@google.com>
+Bhaskar Gupta <guptabhanu1999@gmail.com>
+Smit Gajjar <smitgajjar.gs@gmail.com>
+rbl <rlee@grove.co>
+Ilya Pchelintsev <ilya.pchelintsev@outlook.com>
+Omar Wagih <o.wagih.ow@gmail.com>
+prshnt19 <prashant.rawat216@gmail.com>
+Johan Guzman <jguzm022@ucr.edu>
+Vasileios Kalos <kalosbasileios@gmail.com>
+BasileiosKal <61801875+BasileiosKal@users.noreply.github.com>
+Shubham Thorat <37049710+sbt4104@users.noreply.github.com>
+Arpan Chattopadhyay <f20180319@pilani.bits-pilani.ac.in>
+Ashutosh Hathidara <ashutoshhathidara98@gmail.com>
+Moses Paul R <iammosespaulr@gmail.com>
+Saanidhya vats <saanidhyavats@gmail.com>
+tnzl <you@example.com>
+Vatsal Srivastava <alstav.trivas.sava@gmail.com>
+Jean-Luc Herren <jlh@gmx.ch>
+Dhruv Kothari <dhruvkothari22@gmail.com>
+seadavis <45022599+seadavis@users.noreply.github.com>
+kamimura <kamimura@live.jp>
+slacker404 <pchantza@gmail.com>
+Jaime Resano <gemailpersonal02@gmail.com>
+Ebrahim Byagowi <ebrahim@gnu.org>
+wuyudi <wuyudi119@163.com>
+Akira Kyle <ak@akirakyle.com>
+Calvin Jay Ross <calvinjayross@gmail.com>
+Martin Thoma <info@martin-thoma.de>
+Thomas A Caswell <tcaswell@gmail.com>
+Lagaras Stelios <stel.lag@hotmail.com>
+Jerry James <loganjerry@gmail.com>
+Jan Kruse <janckruse@t-online.de>
+Nathan Taylor <pecan.pine@gmail.com>
+Vaishnav Damani <vaishnavdamani3496@gmail.com>
+Mohit Shah <mohitshah3111999@gmail.com>
+Mathias Louboutin <mathias.louboutin@gmail.com>
+Marijan Smetko <marijansmetko123@gmail.com>
+Dave Witte Morris <Dave.Morris@uleth.ca>
+soumi7 <soumibardhan10@gmail.com>
+Zhongshi <zj495@nyu.edu>
+Wes Galbraith <galbwe92@gmail.com>
+KaustubhDamania <kaustubh.damania@gmail.com>
+w495 <w495@yandex-team.ru>
+Akhil Rajput <akh1lrjput@gmail.com>
+Markus Mohrhard <markus.mohrhard@googlemail.com>
+Benjamin Wolba <mail@benjaminwolba.com>
+彭于斌 <1931127624@qq.com>
+Rudr Tiwari <rudrtiwari@gmail.com>
+Aaryan Dewan <aaryandewan@yahoo.com>
+Benedikt Placke <benedikt.placke@outlook.com>
+Sneha Goddu <s.goddu@wustl.edu>
+goddus <39923708+goddus@users.noreply.github.com>
+Shivang Dubey <shivangdubey8@gmail.com>
+Michael Greminger <michael.greminger@gmail.com>
+Peter Cock <p.j.a.cock@googlemail.com>
+Willem Melching <willem.melching@gmail.com>
+Elias Basler <e.e.basler@protonmail.com>
+Brandon David <brandon.david@zoho.com>
+Abhay_Dhiman <abhaysdhimans@gmail.com>
+Tasha Kim <jae_young_kim@brown.edu>
+Ayush Malik <ayushmalik779@gmail.com>
+Devesh Sawant <devesh47cool@gmail.com>
+Wolfgang Stöcher <wolfgang@stoecher.com>
+Sudeep Sidhu <sudeepmanilsidhu@gmail.com>
+foice <foice.news@gmail.com>
+Ben Payne <ben.is.located@gmail.com>
+Muskan Kumar <31043527+muskanvk@users.noreply.github.com>
+noam simcha finkelstein <noam.finkelstein@protonmail.com>
+Garrett Folbe <gmfolbe@yahoo.com>
+Islam Mansour <is3mansour@gmail.com>
+Sayandip Halder <sayandiph4@gmail.com>
+Shubham Agrawal <shubham.ag6845@gmail.com>
+numbermaniac <5206120+numbermaniac@users.noreply.github.com>
+Sakirul Alam <binarysakir@gmail.com>
+Mohammed Bilal <r.mohammedbilal@gmail.com>
+Chris du Plessis <christopherjonduplessis@gmail.com>
+Coder-RG <rgoel1999@gmail.com>
+Ansh Mishra <anshmishra471@gmail.com>
+Alex Malins <github@alexmalins.com>
+Lorenzo Contento <lorenzo.contento@gmail.com>
+Naveen Sai <naveensaisreenivas@gmail.com>
+Shital Mule <shitalmule04@gmail.com>
+Amanda Dsouza <meezamanda@yahoo.com>
+Nijso Beishuizen <nijso@koolmees.numerically-related.com>
+Harry Zheng <harry@harryzheng.com>
+Felix Yan <felixonmars@archlinux.org>
+Constantin Mateescu <costica1234@me.com>
+Eva Tiwari <eva.tiwari@gmail.com>
+Aditya Kumar Sinha <adityakumar113141@gmail.com>
+Soumi Bardhan <51290447+Soumi7@users.noreply.github.com>
+Kaustubh Chaudhari <ckaustubhm06@gmail.com>
+Kristian Brünn <hello@kristianbrunn.com>
+Neel Gorasiya <mgorasiya1974@gmail.com>
+Akshat Sood <68052998+akshatsood2249@users.noreply.github.com>
+Jose M. Gomez <chemoki@gmail.com>
+Stefan Petrea <stefan@garage-coding.com>
+Praveen Sahu <povinsahu@gmail.com>
+Mark Bell <mark00bell@googlemail.com>
+AlexCQY <alex_chua@u.nus.edu>
+Fabian Froehlich <fabian@schaluck.com>
+Nikhil Gopalam <gopalamn@umich.edu>
+Kartik Sethi <kartiks31416@gmail.com>
+Muhammed Abdul Quadir Owais <quadirowais200@gmail.com>
+Harshit Yadav <harshityadav2k@gmail.com>
+Sidharth Mundhra <sidharthmundhra16@gmail.com>
+Suryam Arnav Kalra <suryamkalra35@gmail.com>
+Prince Gupta <codemastercpp@gmail.com>
+Kunal Singh <ksingh19136@gmail.com>
+Mayank Raj <mayank_1901cs35@iitp.ac.in>
+Achal Jain <2achaljain@gmail.com>
+Mario Maio <mario.maio@aruba.it>
+Aaron Stiff <69512633+AaronStiff@users.noreply.github.com>
+Wyatt Peak <wyattpeak@gmail.com>
+Bhaskar Joshi <bhaskar.joshi@research.iiit.ac.in>
+Aditya Jindal <jaditya8889@gmail.com>
+Vaibhav Bhat <vaibhav.bhat2097@gmail.com>
+Priyansh Rathi <techiepriyansh@gmail.com>
+Saket Kumar Singh <saketkumar1202@gmail.com>
+Yukai Chou <muzimuzhi@gmail.com>
+Qijia Liu <liumeo@pku.edu.cn>
+Paul Mandel <paulmandel@google.com>
+Nisarg Chaudhari <54911392+Nisarg-Chaudhari@users.noreply.github.com>
+Dominik Stańczak <stanczakdominik@gmail.com>
+Rodrigo Luger <rodluger@gmail.com>
+Marco Antônio Habitzreuter <mahabitzreuter@gmail.com>
+Ayush Bisht <bisht.ayush2001@gmail.com>
+Akshansh Bhatt <akshansh@tuta.io>
+Brandon T. Willard <brandonwillard@users.noreply.github.com>
+Thomas Aarholt <thomasaarholt@gmail.com>
+Hiren Chalodiya <hirenchalodiya99@gmail.com>
+Roland Dixon <rols121@gmail.com>
+dimasvq <dimas.vq.2020@bristol.ac.uk>
+Sagar231 <sagarfeb298@gmail.com>
+Michael Chu <michael02chu@gmail.com>
+Abby Ng <abigailjng@gmail.com>
+Angad Sandhu <55819847+angadsinghsandhu@users.noreply.github.com>
+Alexander Cockburn <alexander_cockburn12@hotmail.com>
+Yaser AlOsh <yaseralosh@outlook.com>
+Davide Sandonà <sandona.davide@gmail.com>
+Jonathan Gutow <gutow@uwosh.edu>
+Nihir Agarwal <f20180701@pilani.bits-pilani.ac.in>
+Lee Johnston <lee.johnston.100@gmail.com>
+Zach Carmichael <20629897+craymichael@users.noreply.github.com>
+Vijairam Ganesh Moorthy <vijairamg@gmail.com>
+Hanspeter Schmid <hanspeter.schmid@fhnw.ch>
+Ben Oostendorp <oostben@umich.edu>
+Nikita <nikita.student.cse19@itbhu.ac.in>
+Aman <amanmourya295@gmail.com>
+Shashank KS <shashankks0987@gmail.com>
+Aman Sharma <amansharma110603@gmail.com>
+Anup Parikh <parikhanupk@gmail.com>
+Lucy Mountain <lucymountain1@icloud.com>
+Miguel Torres Costa <miguelptcosta1995@gmail.com>
+Rikard Nordgren <rikard.nordgren@farmaci.uu.se>
+Arun sanganal <74652697+ArunSanganal@users.noreply.github.com>
+Kamlesh Joshi <72374645+kamleshjoshi8102@users.noreply.github.com>
+Joseph Rance <56409230+Joseph-Rance@users.noreply.github.com>
+Huangduirong <huangduirong@huawei.com>
+Nils Schulte <47043622+Schnilz@users.noreply.github.com>
+Matt Bogosian <matt@bogosian.net>
+Elisha Hollander <just4now666666@gmail.com>
+Aditya Ravuri <infprobscix@gmail.com>
+Mamidi Ratna Praneeth <praneethratna@gmail.com>
+Jeffrey Ryan <jeffaryan7@gmail.com>
+Jonathan Daniel <36337649+jond01@users.noreply.github.com>
+Robin Richard <raisin@ecomail.fr>
+Gautam Menghani <gum3ng@protonmail.com>
+Remco de Boer <29308176+redeboer@users.noreply.github.com>
+Sebastian East <sebastianeast@ymail.com>
+Evani Balasubramanyam <balasubramanyam.evani@gmail.com>
+Rahil Parikh <r.parikh@somaiya.edu>
+Jason Ross <jasonross1024@gmail.com>
+Joannah Nanjekye <joannah.nanjekye@ibm.com>
+Ayush Kumar <ayushk7102@gmail.com>
+Kshitij <kshitijparwani.mat18@itbhu.ac.in>
+Daniel Hyams <dhyams@gmail.com>
+alijosephine <alijosephine@gmail.com>
+Matthias Köppe <mkoeppe@math.ucdavis.edu>
+mohajain <mohajain99@gmail.com>
+Anibal M. Medina-Mardones <ammedmar@gmail.com>
+Travis Ens <ens.travis@gmail.com>
+Evgenia Karunus <lakesare@gmail.com>
+Risiraj Dey <risirajdey@gmail.com>
+lastcodestanding <rohang71604@gmail.com>
+Andrey Lekar <andrey_lekar@adoriasoft.com>
+Abbas Mohammed <42001049+iam-abbas@users.noreply.github.com>
+Anutosh Bhat <andersonbhat491@gmail.com>
+Steve Kieffer <sk@skieffer.info>
+Paul Spiering <paul@spiering.org>
+Pieter Gijsbers <p.gijsbers@tue.nl>
+Wang Ran (汪然) <wangr@smail.nju.edu.cn>
+naelsondouglas <naelson17@gmail.com>
+Aman Thakur <thakuraman22july@gmail.com>
+S. Hanko <suzy.hanko@gmail.com>
+Dennis Sweeney <sweeney.427@osu.edu>
+Gurpartap Singh <dhaliwal.gurpartap@gmail.com>
+Hampus Malmberg <hampus.malmberg88@gmail.com>
+scimax <max.kellermeier@hotmail.de>
+Nikhil Date <nikhil.s.date@gmail.com>
+Kuldeep Borkar Jr <kuldeepborkarjr765@gmail.com>
+AkuBrain <76952313+Franck2111@users.noreply.github.com>
+Leo Battle <leowbattle@gmail.com>
+Advait Pote <apote2050@gmail.com>
+Anurag Bhat <bhat.1@iitj.ac.in>
+Jeremy Monat <jemonat@calalum.org>
+Diane Tchuindjo <dtchuindjo@gmail.com>
+Tom Fryers <61272761+TomFryers@users.noreply.github.com>
+Zouhair <zouhair.mahboubi@gmail.com>
+zzj <29055749+zjzh@users.noreply.github.com>
+shubhayu09 <guptashubhayu601@gmail.com>
+Siddhant Jain <siddhantashoknagar@gmail.com>
+Tirthankar Mazumder <63574588+wermos@users.noreply.github.com>
+Sumit Kumar <mr.sumitkrr@gmail.com>
+Shivam Sagar <technoshivam12@gmail.com>
+Gaurav Jain <gjain369@gmail.com>
+Andrii Oriekhov <andriyorehov@gmail.com>
+Luis Talavera <luisfertalavera15@gmail.com>
+Arie Bovenberg <a.c.bovenberg@gmail.com>
+Carson McManus <carson.mcmanus1@gmail.com>
+Jack Schmidt <1107865+jackschmidt@users.noreply.github.com>
+Riley Britten <nrb1324@hotmail.com>
+Georges Khaznadar <georgesk@debian.org>
+Donald Wilson <donwilson1029@gmail.com>
+Timo Stienstra <timostienstra00@gmail.com>
+dispasha <dispasha@users.noreply.github.com>
+Saksham Alok <sakshamalok13@gmail.com>
+Varenyam Bhardwaj <varenyambhardwaj123@gmail.com>
+oittaa <8972248+oittaa@users.noreply.github.com>
+Omkaar <79257339+Pysics@users.noreply.github.com>
+Islem BOUZENIA <fi_bouzenia@esi.dz>
+extraymond <extraymond@gmail.com>
+Alexander Behrens <alex.git@gmx.net>
+user202729 <25191436+user202729@users.noreply.github.com>
+Pieter Eendebak <pieter.eendebak@gmail.com>
+Zaz Brown <zazbrown@zazbrown.com>
+ritikBhandari <ritikbhandari68@gmail.com>
+viocha <66580331+viocha@users.noreply.github.com>
+Arthur Ryman <arthur.ryman@gmail.com>
+Xiang Wu <hsiangwu@fb.com>
+tttc3 <T.Coxon2@lboro.ac.uk>
+Seth Poulsen <poulsenseth@yahoo.com>
+cocolato <haiizhu@outlook.com>
+Anton Golovanov <agolovanov256@gmail.com>
+Gareth Ma <grhkm21@gmail.com>
+Clément M.T. Robert <cr52@protonmail.com>
+Glenn Horton-Smith <glenn.hortonsmith@gmail.com>
+Karan <grgkaran03@gmail.com>
+Stefan Behnle <84378403+behnle@users.noreply.github.com>
+Shreyash Mishra <72146041+Shreyash-cyber@users.noreply.github.com>
+Arthur Milchior <arthur@milchior.fr>
+NotWearingPants <26556598+NotWearingPants@users.noreply.github.com>
+Ishan Pandhare <ishan9096137017@gmail.com>
+Carlos García Montoro <TrilceAC@gmail.com>
+Parcly Taxel <reddeloostw@gmail.com>
+Saicharan <saicharanhahaha@gmail.com>
+Kunal Sheth <kunal@kunalsheth.info>
+Biswadeep Purkayastha <98874428+metabiswadeep@users.noreply.github.com>
+Jyn Spring 琴春 <me@vx.st>
+Phil LeMaitre <phil_lemaitre@live.ca>
+Chris Kerr <chris.kerr@mykolab.ch>
+José Senart <jose.senart@gmail.com>
+Uwe L. Korn <uwelk@xhochy.com>
+ForeverHaibara <69423537+ForeverHaibara@users.noreply.github.com>
+Yves Tumushimire <yvestumushimire@gmail.com>
+wookie184 <wookie1840@gmail.com>
+Costor <pcs2009@web.de>
+Klaus Rettinghaus <klaus.rettinghaus@enote.com>
+Sam Brockie <sambrockie@icloud.com>
+Abhishek Patidar <1e9abhi1e10@gmail.com>
+Eric Demer <demer@mailbox.org>
+Pontus von Brömssen <pontus.vonbromssen+github@gmail.com>
+Victor Immanuel <chrollolucilfer1402@gmail.com>
+Evandro Bernardes <evbernardes@gmail.com>
+Michele Ceccacci <michelececcacci1@gmail.com>
+Ayush Aryan <ayush.aryan71@gmail.com>
+Kishore Gopalakrishnan <kishore96@gmail.com>
+Jan-Philipp Hoffmann <sonntagsgesicht@icloud.com>
+Daiki Takahashi <haru.td@gmail.com>
+Sayan Mitra <ee18b156@smail.iitm.ac.in>
+Aman Kumar Shukla <theprofessionalaman@gmail.com>
+Zoufiné Lauer-Baré <raszoufine@gmail.com>
+Charles Harris <erdos4d@gmail.com>
+Tejaswini Sanapathi <sastejaswini2002@gmail.com>
+Devansh <be19b002@smail.iitm.ac.in>
+Aaron Gokaslan <aaronGokaslan@gmail.com>
+Daan Koning (he/him) <daanolivierkoning@gmail.com>
+Steven Burns <royalstream@hotmail.com>
+Jay Patankar <patankarjays@gmail.com>
+Vivek Soni <sonisheela1977@gmail.com>
+Le Cong Minh Hieu <hieu.lecongminh@gmail.com>
+Sam Ritchie <sam@mentat.org>
+Maciej Skórski <maciej.skorski@gmail.com>
+Tilo Reneau-Cardoso <tiloreneau@gmail.com>
+Laurence Warne <laurencewarne@gmail.com>
+Lukas Molleman <Lukas.Molleman@gmail.com>
+Konstantinos Riganas <kostasriganas24@gmail.com>
+Grace Su <grace.duansu@gmail.com>
+Pedro Rosa <pedro_sxbr@usp.br>
+Abhinav Cillanki <abhinavcillanki@kgpian.iitkgp.ac.in>
+Baiyuan Qiu <1061688677@qq.com>
+Liwei Cai <cai.lw123@gmail.com>
+Daniel Weindl <daniel.weindl@helmholtz-muenchen.de>
+Isidora Araya <iarayaday@gmail.com>
+Seb Tiburzio <sebtiburzio@gmail.com>
+Victory Omole <vtomole2@gmail.com>
+Abhishek Chaudhary <ac5003@columbia.edu>
+Alexander Zhura <nice.zhura@list.ru>
+Shuai Zhou <shuaivzhou@berkeley.edu>
+Martin Manns <mmanns@gmx.net>
+John Möller <john.moller@outlook.com>
+zzc <1378113190@qq.com>
+Pablo Galindo Salgado <pablogsal@gmail.com>
+Johannes Kasimir <johannes.kasimir@math.lu.se>
+Theodore Dias <theodore.dias@hotmail.co.uk>
+Kaustubh <90597818+kaustubh-765@users.noreply.github.com>
+Idan Pazi <idan.kp@gmail.com>
+Bobby Palmer <bobbyp@umich.edu>
+Saikat Das <saikatdchhe@gmail.com>
+Suman mondal <smondal.qwerty@gmail.com>
+Taylan Sahin <info@taylansahin.net>
+Fabio Luporini <fabio@devitocodes.com>
+Oriel Malihi <orielmalihi1@gmail.com>
+Geetika Vadali <geetika.vadali4@gmail.com>
+Matthias Rettl <matthias.rettl@stud.unileoben.ac.at>
+Mikhail Remnev <maremnev@gmail.com>
+philwillnyc <56197213+philwillnyc@users.noreply.github.com>
+Raphael Lehner <raphael.lehner@gmail.com>
+Harry Mountain <harrymountain1@icloud.com>
+Bhavik Sachdev <b.sachdev1904@gmail.com>
+袁野 (Yuan Ye) <yuanyelele@tutanota.com>
+fazledyn-or <ataf@openrefactory.com>
+mohammedouahman <simofun85@gmail.com>
+K. Kraus <laqueray@googlemail.com>
+Zac Hatfield-Dodds <zac.hatfield.dodds@gmail.com>
+platypus <platypus.computerchip@gmail.com>
+codecruisader <nnisarg55@gmail.com>
+James Whitehead <whiteheadj@gmail.com>
+atharvParlikar <atharvparlikar@gmail.com>
+Ivan Petukhov <satels@gmail.com>
+Augusto Borges <borges.augustoar@gmail.com>
+Han Wei Ang <ang.h.w@u.nus.edu>
+Congxu Yang <u7189828@anu.edu.au>
+Saicharan <62512681+saicharan2804@users.noreply.github.com>
+Arnab Nandi <arnabnandi2002@gmail.com>
+Harrison Oates <48871176+HarrisonOates@users.noreply.github.com>
+Corey Cerovsek <corey@cerovsek.com>
+Harsh Kasat <hkasat@waymore.io>
+omahs <73983677+omahs@users.noreply.github.com>
+Pascal Gitz <pascal.gitz@hotmail.ch>
+Ravindu-Hirimuthugoda <ravindu.18@cse.mrt.ac.lk>
+Sophia Pustova <tripplezzed@gmail.com>
+George Pittock <gpittock4@gmail.com>
+Warren Jacinto <warrenjacinto@gmail.com>
+Sachin Singh <sachinishu02@gmail.com>
+Zedmat <104870914+harshkasat@users.noreply.github.com>
+Soumendra Ganguly <soumendraganguly@gmail.com>
+Samith Karunathilake <55777141+samithkavishke@users.noreply.github.com>
+Viraj Vekaria <virajv5593@gmail.com>
+Shishir Kushwaha <kushwahashishir1112@gmail.com>
+Ankit Kumar Singh <ankitdiswar10@gmail.com>
+Abhishek Kumar <abhishek.nitdelhi@gmail.com>
+Mohak Malviya <mohakmalviya2000@gmail.com>
+Matthias Liesenfeld <116307294+maliesen@users.noreply.github.com>
+dodo <palumbododo@gmail.com>
+Mohamed Rezk <mohrizq895@gmail.com>
+Tommaso Vaccari <05-gesto-follemente@icloud.com>
+Alexis Schotte <alexis.schotte@gmail.com>
+Lauren Yim <31467609+cherryblossom000@users.noreply.github.com>
+Prey Patel <patel.prey@iitgn.ac.in>
+Riccardo Di Girolamo <riccardodigirolamo01@gmail.com>
+Abhishek kumar <kumar325571@gmail.com>
+Sam Lubelsky <sammy56lt@gmail.com>
+Henrique Soares <henrique.c.soares@tecnico.ulisboa.pt>
+Vladimir Sereda <voffch@gmail.com>
+Hwayeon Kang <hwayeonniii@gmail.com>
+Raj Sapale <raj4sapale4@gmail.com>
+Gerald Teschl <gerald.teschl@univie.ac.at>
+Richard Samuel <98638849+samuelard7@users.noreply.github.com>
+HeeJae Chang <hechang@microsoft.com>
+Nick Harder <nharder@umich.edu>
+Ethan DeGuire <ethandeguire@gmail.com>
+Lorenz Winkler <lorenz.winkler@tuwien.ac.at>
+Richard Rodenbusch <rrodenbusch@gmail.com>
+Zhenxu Zhu <xzdlj@outlook.com>
+Mark van Gelder <m.j.vangelder@student.tudelft.nl>
+Mark van Gelder <mvgmvgmvg@live.com>
+Ishan Pandhare <91841626+Ishanned@users.noreply.github.com>
+James A. Preiss <jamesalanpreiss@gmail.com>
+Emile Fourcini <emile.fourcin1@gmail.com>
+Alberto Jiménez Ruiz <Alberto.Jimenez@uclm.es>
+João Bravo <joaocgbravo@tecnico.ulisboa.pt>
+Dean Price <dean1357price1357@gmail.com>
+Edward Z. Yang <ezyang@mit.edu>
+James Titus <titusjames299@gmail.com>
+Zhuoyuan Li <zy.li@stu.pku.edu.cn>
+Hugo Kerstens <hugo@kerstens.me>
+Jan Jancar <johny@neuromancer.sk>
+Andrew Mosson <amosson@yahoo.com>
+Marek Madejski <marekmadejski@yandex.com>
+Gonzalo Tornaría <tornaria@cmat.edu.uy>
+Peter Stahlecker <peter.stahlecker@gmail.com>
+Jean-François B <2589111+jfbu@users.noreply.github.com>
+Zexuan Zhou (Bruce) <zzx498636727@gmail.com>
+George Frolov <gosha@fro.lv>
+Corbet Elkins <corbet286@gmail.com>
+Håkon Kvernmoen <haakon.kvernmoen@gmail.com>
+Muhammad Maaz <mmaaz6004@gmail.com>
+Shishir Kushwaha <138311586+shishir-11@users.noreply.github.com>
+Matt Wang <mattwang44@gmail.com>
+bharatAmeria <21001019007@jcboseust.ac.in>
+Amir Ebrahimi <github@aebrahimi.com>
+Steven Esquea <steven.esquea@irreverente.net>
+Rishabh Kamboj <111004091+VectorNd@users.noreply.github.com>
+Aasim Ali <aasim250205@gmail.com>
+Ivan A. Melnikov <iv@altlinux.org>
+Borek Saheli <boreksaheli@gmail.com>
+Guido Roncarolo <guido.roncarolo@gmail.com>
+Quek Zi Yao <ziyaoqzy2001@gmail.com>
+Roelof Rietbroek <r.rietbroek@utwente.nl>
+MostafaGalal1 <mostafag649.mg@gmail.com>
+Au Huishan <huishan_au@outlook.com>
+Kris Katterjohn <katterjohn@gmail.com>
+Shiyao Guo <mivikq@gmail.com>
+Rushabh Mehta <mehtarushabh2005@gmail.com>
+Temiloluwa Yusuf ytemiloluwa@gmail.com ytemiloluwa <ytemiloluwa@gmail.com>
+Davi Laerte <davilae011@gmail.com>
+Agriya Khetarpal <74401230+agriyakhetarpal@users.noreply.github.com>
+Harshit Gupta <harshithigh2001@gmail.com>
+Praveen Perumal <ppraveen98841@gmail.com>
+Kevin McWhirter <klmcw@yahoo.com>
+Prayag V <v.prayag2005@gmail.com>
+Lucas Kletzander <lucas.kletzander@gmail.com>
+Pratyksh Gupta <pratykshgupta9999@gmail.com>
+Leonardo Mangani <leomangani4@gmail.com>
+Karan Anand <anandkarancompsci@gmail.com>
+Gagan Mishra <simonsimple305@gmail.com>
+Krishnav Bajoria <bajoriakrishnav@gmail.com>
+Matt Ord <matthew.ord1@gmail.com>
+Jatin Bhardwaj <bhardwajjatin093@gmail.com>
+Prashant Tandon <tandonprashant101@gmail.com>
+Paramjit Singh <paramjit1071@gmail.com>
+João Rodrigues <abcjoao@hotmail.com>
+Alejandro García Prada <114813960+AlexGarciaPrada@users.noreply.github.com>
+Matthew Treinish <mtreinish@kortar.org>
+Clayton Rabideau <claytonrabideau@gmail.com>
+Victoria Koval <bictoriakoval16@gmail.com>
+Voaides Negustor Robert <134785947+voaidesr@users.noreply.github.com>
+Ovsk Mendov <bbb23exposed@gmail.com>
+David Brooks <dave@bcs.co.nz>
+Nicholas Laustrup <124007393+nicklaustrup@users.noreply.github.com>
+Harikrishna Srinivasan <harikrishnasri3@gmail.com>
+Mathis Cros <mathis.cros@telecom-paris.fr>
+Arnav Mummineni <45217840+RCoder01@users.noreply.github.com>
+Thangaraju Sibiraj <85477603+t-sibiraj@users.noreply.github.com>
+KJaybhaye <krushnajaybhaye01@gmail.com>

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/licenses/LICENSE

@@ -0,0 +1,153 @@
+Copyright (c) 2006-2023 SymPy Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of SymPy nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+Patches that were taken from the Diofant project (https://github.com/diofant/diofant)
+are licensed as:
+
+Copyright (c) 2006-2018 SymPy Development Team,
+              2013-2023 Sergey B Kirpichev
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of Diofant or SymPy nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+Submodules taken from the multipledispatch project (https://github.com/mrocklin/multipledispatch)
+are licensed as:
+
+Copyright (c) 2014 Matthew Rocklin
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of multipledispatch nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+--------------------------------------------------------------------------------
+
+The files under the directory sympy/parsing/autolev/tests/pydy-example-repo
+are directly copied from PyDy project and are licensed as:
+
+Copyright (c) 2009-2023, PyDy Authors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this project nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PYDY AUTHORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------
+
+The files under the directory sympy/parsing/latex 
+are directly copied from latex2sympy project and are licensed as:
+
+Copyright 2016, latex2sympy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.venv/lib/python3.12/site-packages/sympy-1.14.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+isympy
+sympy

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_compound_rv.py

@@ -0,0 +1,159 @@
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.sets.sets import Interval
+from sympy.stats import (Normal, P, E, density, Gamma, Poisson, Rayleigh,
+                        variance, Bernoulli, Beta, Uniform, cdf)
+from sympy.stats.compound_rv import CompoundDistribution, CompoundPSpace
+from sympy.stats.crv_types import NormalDistribution
+from sympy.stats.drv_types import PoissonDistribution
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.testing.pytest import raises, ignore_warnings
+from sympy.stats.joint_rv_types import MultivariateNormalDistribution
+
+from sympy.abc import x
+
+
+# helpers for testing troublesome unevaluated expressions
+flat = lambda s: ''.join(str(s).split())
+streq = lambda *a: len(set(map(flat, a))) == 1
+assert streq(x, x)
+assert streq(x, 'x')
+assert not streq(x, x + 1)
+
+
+def test_normal_CompoundDist():
+    X = Normal('X', 1, 2)
+    Y = Normal('X', X, 4)
+    assert density(Y)(x).simplify() == sqrt(10)*exp(-x**2/40 + x/20 - S(1)/40)/(20*sqrt(pi))
+    assert E(Y) == 1 # it is always equal to mean of X
+    assert P(Y > 1) == S(1)/2 # as 1 is the mean
+    assert P(Y > 5).simplify() ==  S(1)/2 - erf(sqrt(10)/5)/2
+    assert variance(Y) == variance(X) + 4**2 # 2**2 + 4**2
+    # https://math.stackexchange.com/questions/1484451/
+    # (Contains proof of E and variance computation)
+
+
+def test_poisson_CompoundDist():
+    k, t, y = symbols('k t y', positive=True, real=True)
+    G = Gamma('G', k, t)
+    D = Poisson('P', G)
+    assert density(D)(y).simplify() == t**y*(t + 1)**(-k - y)*gamma(k + y)/(gamma(k)*gamma(y + 1))
+    # https://en.wikipedia.org/wiki/Negative_binomial_distribution#Gamma%E2%80%93Poisson_mixture
+    assert E(D).simplify() == k*t # mean of NegativeBinomialDistribution
+
+
+def test_bernoulli_CompoundDist():
+    X = Beta('X', 1, 2)
+    Y = Bernoulli('Y', X)
+    assert density(Y).dict == {0: S(2)/3, 1: S(1)/3}
+    assert E(Y) == P(Eq(Y, 1)) == S(1)/3
+    assert variance(Y) == S(2)/9
+    assert cdf(Y) == {0: S(2)/3, 1: 1}
+
+    # test issue 8128
+    a = Bernoulli('a', S(1)/2)
+    b = Bernoulli('b', a)
+    assert density(b).dict == {0: S(1)/2, 1: S(1)/2}
+    assert P(b > 0.5) == S(1)/2
+
+    X = Uniform('X', 0, 1)
+    Y = Bernoulli('Y', X)
+    assert E(Y) == S(1)/2
+    assert P(Eq(Y, 1)) == E(Y)
+
+
+def test_unevaluated_CompoundDist():
+    # these tests need to be removed once they work with evaluation as they are currently not
+    # evaluated completely in sympy.
+    R = Rayleigh('R', 4)
+    X = Normal('X', 3, R)
+    ans = '''
+        Piecewise(((-sqrt(pi)*sinh(x/4 - 3/4) + sqrt(pi)*cosh(x/4 - 3/4))/(
+        8*sqrt(pi)), Abs(arg(x - 3)) <= pi/4), (Integral(sqrt(2)*exp(-(x - 3)
+        **2/(2*R**2))*exp(-R**2/32)/(32*sqrt(pi)), (R, 0, oo)), True))'''
+    assert streq(density(X)(x), ans)
+
+    expre = '''
+        Integral(X*Integral(sqrt(2)*exp(-(X-3)**2/(2*R**2))*exp(-R**2/32)/(32*
+        sqrt(pi)),(R,0,oo)),(X,-oo,oo))'''
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert streq(E(X, evaluate=False).rewrite(Integral), expre)
+
+    X = Poisson('X', 1)
+    Y = Poisson('Y', X)
+    Z = Poisson('Z', Y)
+    exprd = Sum(exp(-Y)*Y**x*Sum(exp(-1)*exp(-X)*X**Y/(factorial(X)*factorial(Y)
+                ), (X, 0, oo))/factorial(x), (Y, 0, oo))
+    assert density(Z)(x) == exprd
+
+    N = Normal('N', 1, 2)
+    M = Normal('M', 3, 4)
+    D = Normal('D', M, N)
+    exprd = '''
+        Integral(sqrt(2)*exp(-(N-1)**2/8)*Integral(exp(-(x-M)**2/(2*N**2))*exp
+        (-(M-3)**2/32)/(8*pi*N),(M,-oo,oo))/(4*sqrt(pi)),(N,-oo,oo))'''
+    assert streq(density(D, evaluate=False)(x), exprd)
+
+
+def test_Compound_Distribution():
+    X = Normal('X', 2, 4)
+    N = NormalDistribution(X, 4)
+    C = CompoundDistribution(N)
+    assert C.is_Continuous
+    assert C.set == Interval(-oo, oo)
+    assert C.pdf(x, evaluate=True).simplify() == exp(-x**2/64 + x/16 - S(1)/16)/(8*sqrt(pi))
+
+    assert not isinstance(CompoundDistribution(NormalDistribution(2, 3)),
+                            CompoundDistribution)
+    M = MultivariateNormalDistribution([1, 2], [[2, 1], [1, 2]])
+    raises(NotImplementedError, lambda: CompoundDistribution(M))
+
+    X = Beta('X', 2, 4)
+    B = BernoulliDistribution(X, 1, 0)
+    C = CompoundDistribution(B)
+    assert C.is_Finite
+    assert C.set == {0, 1}
+    y = symbols('y', negative=False, integer=True)
+    assert C.pdf(y, evaluate=True) == Piecewise((S(1)/(30*beta(2, 4)), Eq(y, 0)),
+                (S(1)/(60*beta(2, 4)), Eq(y, 1)), (0, True))
+
+    k, t, z = symbols('k t z', positive=True, real=True)
+    G = Gamma('G', k, t)
+    X = PoissonDistribution(G)
+    C = CompoundDistribution(X)
+    assert C.is_Discrete
+    assert C.set == S.Naturals0
+    assert C.pdf(z, evaluate=True).simplify() == t**z*(t + 1)**(-k - z)*gamma(k \
+                    + z)/(gamma(k)*gamma(z + 1))
+
+
+def test_compound_pspace():
+    X = Normal('X', 2, 4)
+    Y = Normal('Y', 3, 6)
+    assert not isinstance(Y.pspace, CompoundPSpace)
+    N = NormalDistribution(1, 2)
+    D = PoissonDistribution(3)
+    B = BernoulliDistribution(0.2, 1, 0)
+    pspace1 = CompoundPSpace('N', N)
+    pspace2 = CompoundPSpace('D', D)
+    pspace3 = CompoundPSpace('B', B)
+    assert not isinstance(pspace1, CompoundPSpace)
+    assert not isinstance(pspace2, CompoundPSpace)
+    assert not isinstance(pspace3, CompoundPSpace)
+    M = MultivariateNormalDistribution([1, 2], [[2, 1], [1, 2]])
+    raises(ValueError, lambda: CompoundPSpace('M', M))
+    Y = Normal('Y', X, 6)
+    assert isinstance(Y.pspace, CompoundPSpace)
+    assert Y.pspace.distribution == CompoundDistribution(NormalDistribution(X, 6))
+    assert Y.pspace.domain.set == Interval(-oo, oo)

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_continuous_rv.py

@@ -0,0 +1,1583 @@
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Lambda, diff, expand_func)
+from sympy.core.mul import Mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import (E as e, I, Rational, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.complexes import (Abs, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (asin, atan, cos, sin, tan)
+from sympy.functions.special.bessel import (besseli, besselj, besselk)
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.error_functions import (erf, erfc, erfi, expint)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma, uppergamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Or)
+from sympy.sets.sets import Interval
+from sympy.simplify.simplify import simplify
+from sympy.utilities.lambdify import lambdify
+from sympy.functions.special.error_functions import erfinv
+from sympy.functions.special.hyper import meijerg
+from sympy.sets.sets import FiniteSet, Complement, Intersection
+from sympy.stats import (P, E, where, density, variance, covariance, skewness, kurtosis, median,
+                         given, pspace, cdf, characteristic_function, moment_generating_function,
+                         ContinuousRV, Arcsin, Benini, Beta, BetaNoncentral, BetaPrime,
+                         Cauchy, Chi, ChiSquared, ChiNoncentral, Dagum, Davis, Erlang, ExGaussian,
+                         Exponential, ExponentialPower, FDistribution, FisherZ, Frechet, Gamma,
+                         GammaInverse, Gompertz, Gumbel, Kumaraswamy, Laplace, Levy, Logistic, LogCauchy,
+                         LogLogistic, LogitNormal, LogNormal, Maxwell, Moyal, Nakagami, Normal, GaussianInverse,
+                         Pareto, PowerFunction, QuadraticU, RaisedCosine, Rayleigh, Reciprocal, ShiftedGompertz, StudentT,
+                         Trapezoidal, Triangular, Uniform, UniformSum, VonMises, Weibull, coskewness,
+                         WignerSemicircle, Wald, correlation, moment, cmoment, smoment, quantile,
+                         Lomax, BoundedPareto)
+
+from sympy.stats.crv_types import NormalDistribution, ExponentialDistribution, ContinuousDistributionHandmade
+from sympy.stats.joint_rv_types import MultivariateLaplaceDistribution, MultivariateNormalDistribution
+from sympy.stats.crv import SingleContinuousPSpace, SingleContinuousDomain
+from sympy.stats.compound_rv import CompoundPSpace
+from sympy.stats.symbolic_probability import Probability
+from sympy.testing.pytest import raises, XFAIL, slow, ignore_warnings
+from sympy.core.random import verify_numerically as tn
+
+oo = S.Infinity
+
+x, y, z = map(Symbol, 'xyz')
+
+def test_single_normal():
+    mu = Symbol('mu', real=True)
+    sigma = Symbol('sigma', positive=True)
+    X = Normal('x', 0, 1)
+    Y = X*sigma + mu
+
+    assert E(Y) == mu
+    assert variance(Y) == sigma**2
+    pdf = density(Y)
+    x = Symbol('x', real=True)
+    assert (pdf(x) ==
+            2**S.Half*exp(-(x - mu)**2/(2*sigma**2))/(2*pi**S.Half*sigma))
+
+    assert P(X**2 < 1) == erf(2**S.Half/2)
+    ans = quantile(Y)(x)
+    assert ans == Complement(Intersection(FiniteSet(
+        sqrt(2)*sigma*(sqrt(2)*mu/(2*sigma)+ erfinv(2*x - 1))),
+        Interval(-oo, oo)), FiniteSet(mu))
+    assert E(X, Eq(X, mu)) == mu
+
+    assert median(X) == FiniteSet(0)
+    # issue 8248
+    assert X.pspace.compute_expectation(1).doit() == 1
+
+
+def test_conditional_1d():
+    X = Normal('x', 0, 1)
+    Y = given(X, X >= 0)
+    z = Symbol('z')
+
+    assert density(Y)(z) == 2 * density(X)(z)
+
+    assert Y.pspace.domain.set == Interval(0, oo)
+    assert E(Y) == sqrt(2) / sqrt(pi)
+
+    assert E(X**2) == E(Y**2)
+
+
+def test_ContinuousDomain():
+    X = Normal('x', 0, 1)
+    assert where(X**2 <= 1).set == Interval(-1, 1)
+    assert where(X**2 <= 1).symbol == X.symbol
+    assert where(And(X**2 <= 1, X >= 0)).set == Interval(0, 1)
+    raises(ValueError, lambda: where(sin(X) > 1))
+
+    Y = given(X, X >= 0)
+
+    assert Y.pspace.domain.set == Interval(0, oo)
+
+
+def test_multiple_normal():
+    X, Y = Normal('x', 0, 1), Normal('y', 0, 1)
+    p = Symbol("p", positive=True)
+
+    assert E(X + Y) == 0
+    assert variance(X + Y) == 2
+    assert variance(X + X) == 4
+    assert covariance(X, Y) == 0
+    assert covariance(2*X + Y, -X) == -2*variance(X)
+    assert skewness(X) == 0
+    assert skewness(X + Y) == 0
+    assert kurtosis(X) == 3
+    assert kurtosis(X+Y) == 3
+    assert correlation(X, Y) == 0
+    assert correlation(X, X + Y) == correlation(X, X - Y)
+    assert moment(X, 2) == 1
+    assert cmoment(X, 3) == 0
+    assert moment(X + Y, 4) == 12
+    assert cmoment(X, 2) == variance(X)
+    assert smoment(X*X, 2) == 1
+    assert smoment(X + Y, 3) == skewness(X + Y)
+    assert smoment(X + Y, 4) == kurtosis(X + Y)
+    assert E(X, Eq(X + Y, 0)) == 0
+    assert variance(X, Eq(X + Y, 0)) == S.Half
+    assert quantile(X)(p) == sqrt(2)*erfinv(2*p - S.One)
+
+
+def test_symbolic():
+    mu1, mu2 = symbols('mu1 mu2', real=True)
+    s1, s2 = symbols('sigma1 sigma2', positive=True)
+    rate = Symbol('lambda', positive=True)
+    X = Normal('x', mu1, s1)
+    Y = Normal('y', mu2, s2)
+    Z = Exponential('z', rate)
+    a, b, c = symbols('a b c', real=True)
+
+    assert E(X) == mu1
+    assert E(X + Y) == mu1 + mu2
+    assert E(a*X + b) == a*E(X) + b
+    assert variance(X) == s1**2
+    assert variance(X + a*Y + b) == variance(X) + a**2*variance(Y)
+
+    assert E(Z) == 1/rate
+    assert E(a*Z + b) == a*E(Z) + b
+    assert E(X + a*Z + b) == mu1 + a/rate + b
+    assert median(X) == FiniteSet(mu1)
+
+
+def test_cdf():
+    X = Normal('x', 0, 1)
+
+    d = cdf(X)
+    assert P(X < 1) == d(1).rewrite(erfc)
+    assert d(0) == S.Half
+
+    d = cdf(X, X > 0)  # given X>0
+    assert d(0) == 0
+
+    Y = Exponential('y', 10)
+    d = cdf(Y)
+    assert d(-5) == 0
+    assert P(Y > 3) == 1 - d(3)
+
+    raises(ValueError, lambda: cdf(X + Y))
+
+    Z = Exponential('z', 1)
+    f = cdf(Z)
+    assert f(z) == Piecewise((1 - exp(-z), z >= 0), (0, True))
+
+
+def test_characteristic_function():
+    X = Uniform('x', 0, 1)
+
+    cf = characteristic_function(X)
+    assert cf(1) == -I*(-1 + exp(I))
+
+    Y = Normal('y', 1, 1)
+    cf = characteristic_function(Y)
+    assert cf(0) == 1
+    assert cf(1) == exp(I - S.Half)
+
+    Z = Exponential('z', 5)
+    cf = characteristic_function(Z)
+    assert cf(0) == 1
+    assert cf(1).expand() == Rational(25, 26) + I*5/26
+
+    X = GaussianInverse('x', 1, 1)
+    cf = characteristic_function(X)
+    assert cf(0) == 1
+    assert cf(1) == exp(1 - sqrt(1 - 2*I))
+
+    X = ExGaussian('x', 0, 1, 1)
+    cf = characteristic_function(X)
+    assert cf(0) == 1
+    assert cf(1) == (1 + I)*exp(Rational(-1, 2))/2
+
+    L = Levy('x', 0, 1)
+    cf = characteristic_function(L)
+    assert cf(0) == 1
+    assert cf(1) == exp(-sqrt(2)*sqrt(-I))
+
+
+def test_moment_generating_function():
+    t = symbols('t', positive=True)
+
+    # Symbolic tests
+    a, b, c = symbols('a b c')
+
+    mgf = moment_generating_function(Beta('x', a, b))(t)
+    assert mgf == hyper((a,), (a + b,), t)
+
+    mgf = moment_generating_function(Chi('x', a))(t)
+    assert mgf == sqrt(2)*t*gamma(a/2 + S.Half)*\
+        hyper((a/2 + S.Half,), (Rational(3, 2),), t**2/2)/gamma(a/2) +\
+        hyper((a/2,), (S.Half,), t**2/2)
+
+    mgf = moment_generating_function(ChiSquared('x', a))(t)
+    assert mgf == (1 - 2*t)**(-a/2)
+
+    mgf = moment_generating_function(Erlang('x', a, b))(t)
+    assert mgf == (1 - t/b)**(-a)
+
+    mgf = moment_generating_function(ExGaussian("x", a, b, c))(t)
+    assert mgf == exp(a*t + b**2*t**2/2)/(1 - t/c)
+
+    mgf = moment_generating_function(Exponential('x', a))(t)
+    assert mgf == a/(a - t)
+
+    mgf = moment_generating_function(Gamma('x', a, b))(t)
+    assert mgf == (-b*t + 1)**(-a)
+
+    mgf = moment_generating_function(Gumbel('x', a, b))(t)
+    assert mgf == exp(b*t)*gamma(-a*t + 1)
+
+    mgf = moment_generating_function(Gompertz('x', a, b))(t)
+    assert mgf == b*exp(b)*expint(t/a, b)
+
+    mgf = moment_generating_function(Laplace('x', a, b))(t)
+    assert mgf == exp(a*t)/(-b**2*t**2 + 1)
+
+    mgf = moment_generating_function(Logistic('x', a, b))(t)
+    assert mgf == exp(a*t)*beta(-b*t + 1, b*t + 1)
+
+    mgf = moment_generating_function(Normal('x', a, b))(t)
+    assert mgf == exp(a*t + b**2*t**2/2)
+
+    mgf = moment_generating_function(Pareto('x', a, b))(t)
+    assert mgf == b*(-a*t)**b*uppergamma(-b, -a*t)
+
+    mgf = moment_generating_function(QuadraticU('x', a, b))(t)
+    assert str(mgf) == ("(3*(t*(-4*b + (a + b)**2) + 4)*exp(b*t) - "
+    "3*(t*(a**2 + 2*a*(b - 2) + b**2) + 4)*exp(a*t))/(t**2*(a - b)**3)")
+
+    mgf = moment_generating_function(RaisedCosine('x', a, b))(t)
+    assert mgf == pi**2*exp(a*t)*sinh(b*t)/(b*t*(b**2*t**2 + pi**2))
+
+    mgf = moment_generating_function(Rayleigh('x', a))(t)
+    assert mgf == sqrt(2)*sqrt(pi)*a*t*(erf(sqrt(2)*a*t/2) + 1)\
+        *exp(a**2*t**2/2)/2 + 1
+
+    mgf = moment_generating_function(Triangular('x', a, b, c))(t)
+    assert str(mgf) == ("(-2*(-a + b)*exp(c*t) + 2*(-a + c)*exp(b*t) + "
+    "2*(b - c)*exp(a*t))/(t**2*(-a + b)*(-a + c)*(b - c))")
+
+    mgf = moment_generating_function(Uniform('x', a, b))(t)
+    assert mgf == (-exp(a*t) + exp(b*t))/(t*(-a + b))
+
+    mgf = moment_generating_function(UniformSum('x', a))(t)
+    assert mgf == ((exp(t) - 1)/t)**a
+
+    mgf = moment_generating_function(WignerSemicircle('x', a))(t)
+    assert mgf == 2*besseli(1, a*t)/(a*t)
+
+    # Numeric tests
+
+    mgf = moment_generating_function(Beta('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == hyper((2,), (3,), 1)/2
+
+    mgf = moment_generating_function(Chi('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == sqrt(2)*hyper((1,), (Rational(3, 2),), S.Half
+    )/sqrt(pi) + hyper((Rational(3, 2),), (Rational(3, 2),), S.Half) + 2*sqrt(2)*hyper((2,),
+    (Rational(5, 2),), S.Half)/(3*sqrt(pi))
+
+    mgf = moment_generating_function(ChiSquared('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == I
+
+    mgf = moment_generating_function(Erlang('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(ExGaussian("x", 0, 1, 1))(t)
+    assert mgf.diff(t).subs(t, 2) == -exp(2)
+
+    mgf = moment_generating_function(Exponential('x', 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(Gamma('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(Gumbel('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == EulerGamma + 1
+
+    mgf = moment_generating_function(Gompertz('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == -e*meijerg(((), (1, 1)),
+    ((0, 0, 0), ()), 1)
+
+    mgf = moment_generating_function(Laplace('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == 1
+
+    mgf = moment_generating_function(Logistic('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == beta(1, 1)
+
+    mgf = moment_generating_function(Normal('x', 0, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == exp(S.Half)
+
+    mgf = moment_generating_function(Pareto('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 0) == expint(1, 0)
+
+    mgf = moment_generating_function(QuadraticU('x', 1, 2))(t)
+    assert mgf.diff(t).subs(t, 1) == -12*e - 3*exp(2)
+
+    mgf = moment_generating_function(RaisedCosine('x', 1, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == -2*e*pi**2*sinh(1)/\
+    (1 + pi**2)**2 + e*pi**2*cosh(1)/(1 + pi**2)
+
+    mgf = moment_generating_function(Rayleigh('x', 1))(t)
+    assert mgf.diff(t).subs(t, 0) == sqrt(2)*sqrt(pi)/2
+
+    mgf = moment_generating_function(Triangular('x', 1, 3, 2))(t)
+    assert mgf.diff(t).subs(t, 1) == -e + exp(3)
+
+    mgf = moment_generating_function(Uniform('x', 0, 1))(t)
+    assert mgf.diff(t).subs(t, 1) == 1
+
+    mgf = moment_generating_function(UniformSum('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == 1
+
+    mgf = moment_generating_function(WignerSemicircle('x', 1))(t)
+    assert mgf.diff(t).subs(t, 1) == -2*besseli(1, 1) + besseli(2, 1) +\
+        besseli(0, 1)
+
+
+def test_ContinuousRV():
+    pdf = sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))  # Normal distribution
+    # X and Y should be equivalent
+    X = ContinuousRV(x, pdf, check=True)
+    Y = Normal('y', 0, 1)
+
+    assert variance(X) == variance(Y)
+    assert P(X > 0) == P(Y > 0)
+    Z = ContinuousRV(z, exp(-z), set=Interval(0, oo))
+    assert Z.pspace.domain.set == Interval(0, oo)
+    assert E(Z) == 1
+    assert P(Z > 5) == exp(-5)
+    raises(ValueError, lambda: ContinuousRV(z, exp(-z), set=Interval(0, 10), check=True))
+
+    # the correct pdf for Gamma(k, theta) but the integral in `check`
+    # integrates to something equivalent to 1 and not to 1 exactly
+    _x, k, theta = symbols("x k theta", positive=True)
+    pdf = 1/(gamma(k)*theta**k)*_x**(k-1)*exp(-_x/theta)
+    X = ContinuousRV(_x, pdf, set=Interval(0, oo))
+    Y = Gamma('y', k, theta)
+    assert (E(X) - E(Y)).simplify() == 0
+    assert (variance(X) - variance(Y)).simplify() == 0
+
+
+def test_arcsin():
+
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+
+    X = Arcsin('x', a, b)
+    assert density(X)(x) == 1/(pi*sqrt((-x + b)*(x - a)))
+    assert cdf(X)(x) == Piecewise((0, a > x),
+                            (2*asin(sqrt((-a + x)/(-a + b)))/pi, b >= x),
+                            (1, True))
+    assert pspace(X).domain.set == Interval(a, b)
+
+def test_benini():
+    alpha = Symbol("alpha", positive=True)
+    beta = Symbol("beta", positive=True)
+    sigma = Symbol("sigma", positive=True)
+    X = Benini('x', alpha, beta, sigma)
+
+    assert density(X)(x) == ((alpha/x + 2*beta*log(x/sigma)/x)
+                          *exp(-alpha*log(x/sigma) - beta*log(x/sigma)**2))
+
+    assert pspace(X).domain.set == Interval(sigma, oo)
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    alpha = Symbol("alpha", nonpositive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+    beta = Symbol("beta", nonpositive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+    alpha = Symbol("alpha", positive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+    beta = Symbol("beta", positive=True)
+    sigma = Symbol("sigma", nonpositive=True)
+    raises(ValueError, lambda: Benini('x', alpha, beta, sigma))
+
+def test_beta():
+    a, b = symbols('alpha beta', positive=True)
+    B = Beta('x', a, b)
+
+    assert pspace(B).domain.set == Interval(0, 1)
+    assert characteristic_function(B)(x) == hyper((a,), (a + b,), I*x)
+    assert density(B)(x) == x**(a - 1)*(1 - x)**(b - 1)/beta(a, b)
+
+    assert simplify(E(B)) == a / (a + b)
+    assert simplify(variance(B)) == a*b / (a**3 + 3*a**2*b + a**2 + 3*a*b**2 + 2*a*b + b**3 + b**2)
+
+    # Full symbolic solution is too much, test with numeric version
+    a, b = 1, 2
+    B = Beta('x', a, b)
+    assert expand_func(E(B)) == a / S(a + b)
+    assert expand_func(variance(B)) == (a*b) / S((a + b)**2 * (a + b + 1))
+    assert median(B) == FiniteSet(1 - 1/sqrt(2))
+
+def test_beta_noncentral():
+    a, b = symbols('a b', positive=True)
+    c = Symbol('c', nonnegative=True)
+    _k = Dummy('k')
+
+    X = BetaNoncentral('x', a, b, c)
+
+    assert pspace(X).domain.set == Interval(0, 1)
+
+    dens = density(X)
+    z = Symbol('z')
+
+    res = Sum( z**(_k + a - 1)*(c/2)**_k*(1 - z)**(b - 1)*exp(-c/2)/
+               (beta(_k + a, b)*factorial(_k)), (_k, 0, oo))
+    assert dens(z).dummy_eq(res)
+
+    # BetaCentral should not raise if the assumptions
+    # on the symbols can not be determined
+    a, b, c = symbols('a b c')
+    assert BetaNoncentral('x', a, b, c)
+
+    a = Symbol('a', positive=False, real=True)
+    raises(ValueError, lambda: BetaNoncentral('x', a, b, c))
+
+    a = Symbol('a', positive=True)
+    b = Symbol('b', positive=False, real=True)
+    raises(ValueError, lambda: BetaNoncentral('x', a, b, c))
+
+    a = Symbol('a', positive=True)
+    b = Symbol('b', positive=True)
+    c = Symbol('c', nonnegative=False, real=True)
+    raises(ValueError, lambda: BetaNoncentral('x', a, b, c))
+
+def test_betaprime():
+    alpha = Symbol("alpha", positive=True)
+
+    betap = Symbol("beta", positive=True)
+
+    X = BetaPrime('x', alpha, betap)
+    assert density(X)(x) == x**(alpha - 1)*(x + 1)**(-alpha - betap)/beta(alpha, betap)
+
+    alpha = Symbol("alpha", nonpositive=True)
+    raises(ValueError, lambda: BetaPrime('x', alpha, betap))
+
+    alpha = Symbol("alpha", positive=True)
+    betap = Symbol("beta", nonpositive=True)
+    raises(ValueError, lambda: BetaPrime('x', alpha, betap))
+    X = BetaPrime('x', 1, 1)
+    assert median(X) == FiniteSet(1)
+
+
+def test_BoundedPareto():
+    L, H = symbols('L, H', negative=True)
+    raises(ValueError, lambda: BoundedPareto('X', 1, L, H))
+    L, H = symbols('L, H', real=False)
+    raises(ValueError, lambda: BoundedPareto('X', 1, L, H))
+    L, H = symbols('L, H', positive=True)
+    raises(ValueError, lambda: BoundedPareto('X', -1, L, H))
+
+    X = BoundedPareto('X', 2, L, H)
+    assert X.pspace.domain.set == Interval(L, H)
+    assert density(X)(x) == 2*L**2/(x**3*(1 - L**2/H**2))
+    assert cdf(X)(x) == Piecewise((-H**2*L**2/(x**2*(H**2 - L**2)) \
+                            + H**2/(H**2 - L**2), L <= x), (0, True))
+    assert E(X).simplify() == 2*H*L/(H + L)
+    X = BoundedPareto('X', 1, 2, 4)
+    assert E(X).simplify() == log(16)
+    assert median(X) == FiniteSet(Rational(8, 3))
+    assert variance(X).simplify() == 8 - 16*log(2)**2
+
+
+def test_cauchy():
+    x0 = Symbol("x0", real=True)
+    gamma = Symbol("gamma", positive=True)
+    p = Symbol("p", positive=True)
+
+    X = Cauchy('x', x0, gamma)
+    # Tests the characteristic function
+    assert characteristic_function(X)(x) == exp(-gamma*Abs(x) + I*x*x0)
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    assert density(X)(x) == 1/(pi*gamma*(1 + (x - x0)**2/gamma**2))
+    assert diff(cdf(X)(x), x) == density(X)(x)
+    assert quantile(X)(p) == gamma*tan(pi*(p - S.Half)) + x0
+
+    x1 = Symbol("x1", real=False)
+    raises(ValueError, lambda: Cauchy('x', x1, gamma))
+    gamma = Symbol("gamma", nonpositive=True)
+    raises(ValueError, lambda: Cauchy('x', x0, gamma))
+    assert median(X) == FiniteSet(x0)
+
+def test_chi():
+    from sympy.core.numbers import I
+    k = Symbol("k", integer=True)
+
+    X = Chi('x', k)
+    assert density(X)(x) == 2**(-k/2 + 1)*x**(k - 1)*exp(-x**2/2)/gamma(k/2)
+
+    # Tests the characteristic function
+    assert characteristic_function(X)(x) == sqrt(2)*I*x*gamma(k/2 + S(1)/2)*hyper((k/2 + S(1)/2,),
+                                            (S(3)/2,), -x**2/2)/gamma(k/2) + hyper((k/2,), (S(1)/2,), -x**2/2)
+
+    # Tests the moment generating function
+    assert moment_generating_function(X)(x) == sqrt(2)*x*gamma(k/2 + S(1)/2)*hyper((k/2 + S(1)/2,),
+                                                (S(3)/2,), x**2/2)/gamma(k/2) + hyper((k/2,), (S(1)/2,), x**2/2)
+
+    k = Symbol("k", integer=True, positive=False)
+    raises(ValueError, lambda: Chi('x', k))
+
+    k = Symbol("k", integer=False, positive=True)
+    raises(ValueError, lambda: Chi('x', k))
+
+def test_chi_noncentral():
+    k = Symbol("k", integer=True)
+    l = Symbol("l")
+
+    X = ChiNoncentral("x", k, l)
+    assert density(X)(x) == (x**k*l*(x*l)**(-k/2)*
+                          exp(-x**2/2 - l**2/2)*besseli(k/2 - 1, x*l))
+
+    k = Symbol("k", integer=True, positive=False)
+    raises(ValueError, lambda: ChiNoncentral('x', k, l))
+
+    k = Symbol("k", integer=True, positive=True)
+    l = Symbol("l", nonpositive=True)
+    raises(ValueError, lambda: ChiNoncentral('x', k, l))
+
+    k = Symbol("k", integer=False)
+    l = Symbol("l", positive=True)
+    raises(ValueError, lambda: ChiNoncentral('x', k, l))
+
+
+def test_chi_squared():
+    k = Symbol("k", integer=True)
+    X = ChiSquared('x', k)
+
+    # Tests the characteristic function
+    assert characteristic_function(X)(x) == ((-2*I*x + 1)**(-k/2))
+
+    assert density(X)(x) == 2**(-k/2)*x**(k/2 - 1)*exp(-x/2)/gamma(k/2)
+    assert cdf(X)(x) == Piecewise((lowergamma(k/2, x/2)/gamma(k/2), x >= 0), (0, True))
+    assert E(X) == k
+    assert variance(X) == 2*k
+
+    X = ChiSquared('x', 15)
+    assert cdf(X)(3) == -14873*sqrt(6)*exp(Rational(-3, 2))/(5005*sqrt(pi)) + erf(sqrt(6)/2)
+
+    k = Symbol("k", integer=True, positive=False)
+    raises(ValueError, lambda: ChiSquared('x', k))
+
+    k = Symbol("k", integer=False, positive=True)
+    raises(ValueError, lambda: ChiSquared('x', k))
+
+
+def test_dagum():
+    p = Symbol("p", positive=True)
+    b = Symbol("b", positive=True)
+    a = Symbol("a", positive=True)
+
+    X = Dagum('x', p, a, b)
+    assert density(X)(x) == a*p*(x/b)**(a*p)*((x/b)**a + 1)**(-p - 1)/x
+    assert cdf(X)(x) == Piecewise(((1 + (x/b)**(-a))**(-p), x >= 0),
+                                    (0, True))
+
+    p = Symbol("p", nonpositive=True)
+    raises(ValueError, lambda: Dagum('x', p, a, b))
+
+    p = Symbol("p", positive=True)
+    b = Symbol("b", nonpositive=True)
+    raises(ValueError, lambda: Dagum('x', p, a, b))
+
+    b = Symbol("b", positive=True)
+    a = Symbol("a", nonpositive=True)
+    raises(ValueError, lambda: Dagum('x', p, a, b))
+    X = Dagum('x', 1, 1, 1)
+    assert median(X) == FiniteSet(1)
+
+def test_davis():
+    b = Symbol("b", positive=True)
+    n = Symbol("n", positive=True)
+    mu = Symbol("mu", positive=True)
+
+    X = Davis('x', b, n, mu)
+    dividend = b**n*(x - mu)**(-1-n)
+    divisor = (exp(b/(x-mu))-1)*(gamma(n)*zeta(n))
+    assert density(X)(x) == dividend/divisor
+
+
+def test_erlang():
+    k = Symbol("k", integer=True, positive=True)
+    l = Symbol("l", positive=True)
+
+    X = Erlang("x", k, l)
+    assert density(X)(x) == x**(k - 1)*l**k*exp(-x*l)/gamma(k)
+    assert cdf(X)(x) == Piecewise((lowergamma(k, l*x)/gamma(k), x > 0),
+                               (0, True))
+
+
+def test_exgaussian():
+    m, z = symbols("m, z")
+    s, l = symbols("s, l", positive=True)
+    X = ExGaussian("x", m, s, l)
+
+    assert density(X)(z) == l*exp(l*(l*s**2 + 2*m - 2*z)/2) *\
+        erfc(sqrt(2)*(l*s**2 + m - z)/(2*s))/2
+
+    # Note: actual_output simplifies to expected_output.
+    # Ideally cdf(X)(z) would return expected_output
+    # expected_output = (erf(sqrt(2)*(l*s**2 + m - z)/(2*s)) - 1)*exp(l*(l*s**2 + 2*m - 2*z)/2)/2 - erf(sqrt(2)*(m - z)/(2*s))/2 + S.Half
+    u = l*(z - m)
+    v = l*s
+    GaussianCDF1 = cdf(Normal('x', 0, v))(u)
+    GaussianCDF2 = cdf(Normal('x', v**2, v))(u)
+    actual_output = GaussianCDF1 - exp(-u + (v**2/2) + log(GaussianCDF2))
+    assert cdf(X)(z) == actual_output
+    # assert simplify(actual_output) == expected_output
+
+    assert variance(X).expand() == s**2 + l**(-2)
+
+    assert skewness(X).expand() == 2/(l**3*s**2*sqrt(s**2 + l**(-2)) + l *
+                                      sqrt(s**2 + l**(-2)))
+
+
+@slow
+def test_exponential():
+    rate = Symbol('lambda', positive=True)
+    X = Exponential('x', rate)
+    p = Symbol("p", positive=True, real=True)
+
+    assert E(X) == 1/rate
+    assert variance(X) == 1/rate**2
+    assert skewness(X) == 2
+    assert skewness(X) == smoment(X, 3)
+    assert kurtosis(X) == 9
+    assert kurtosis(X) == smoment(X, 4)
+    assert smoment(2*X, 4) == smoment(X, 4)
+    assert moment(X, 3) == 3*2*1/rate**3
+    assert P(X > 0) is S.One
+    assert P(X > 1) == exp(-rate)
+    assert P(X > 10) == exp(-10*rate)
+    assert quantile(X)(p) == -log(1-p)/rate
+
+    assert where(X <= 1).set == Interval(0, 1)
+    Y = Exponential('y', 1)
+    assert median(Y) == FiniteSet(log(2))
+    #Test issue 9970
+    z = Dummy('z')
+    assert P(X > z) == exp(-z*rate)
+    assert P(X < z) == 0
+    #Test issue 10076 (Distribution with interval(0,oo))
+    x = Symbol('x')
+    _z = Dummy('_z')
+    b = SingleContinuousPSpace(x, ExponentialDistribution(2))
+
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        expected1 = Integral(2*exp(-2*_z), (_z, 3, oo))
+        assert b.probability(x > 3, evaluate=False).rewrite(Integral).dummy_eq(expected1)
+
+        expected2 = Integral(2*exp(-2*_z), (_z, 0, 4))
+        assert b.probability(x < 4, evaluate=False).rewrite(Integral).dummy_eq(expected2)
+    Y = Exponential('y', 2*rate)
+    assert coskewness(X, X, X) == skewness(X)
+    assert coskewness(X, Y + rate*X, Y + 2*rate*X) == \
+                        4/(sqrt(1 + 1/(4*rate**2))*sqrt(4 + 1/(4*rate**2)))
+    assert coskewness(X + 2*Y, Y + X, Y + 2*X, X > 3) == \
+                        sqrt(170)*Rational(9, 85)
+
+def test_exponential_power():
+    mu = Symbol('mu')
+    z = Symbol('z')
+    alpha = Symbol('alpha', positive=True)
+    beta = Symbol('beta', positive=True)
+
+    X = ExponentialPower('x', mu, alpha, beta)
+
+    assert density(X)(z) == beta*exp(-(Abs(mu - z)/alpha)
+                                     ** beta)/(2*alpha*gamma(1/beta))
+    assert cdf(X)(z) == S.Half + lowergamma(1/beta,
+                            (Abs(mu - z)/alpha)**beta)*sign(-mu + z)/\
+                                (2*gamma(1/beta))
+
+
+def test_f_distribution():
+    d1 = Symbol("d1", positive=True)
+    d2 = Symbol("d2", positive=True)
+
+    X = FDistribution("x", d1, d2)
+
+    assert density(X)(x) == (d2**(d2/2)*sqrt((d1*x)**d1*(d1*x + d2)**(-d1 - d2))
+                             /(x*beta(d1/2, d2/2)))
+
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    d1 = Symbol("d1", nonpositive=True)
+    raises(ValueError, lambda: FDistribution('x', d1, d1))
+
+    d1 = Symbol("d1", positive=True, integer=False)
+    raises(ValueError, lambda: FDistribution('x', d1, d1))
+
+    d1 = Symbol("d1", positive=True)
+    d2 = Symbol("d2", nonpositive=True)
+    raises(ValueError, lambda: FDistribution('x', d1, d2))
+
+    d2 = Symbol("d2", positive=True, integer=False)
+    raises(ValueError, lambda: FDistribution('x', d1, d2))
+
+
+def test_fisher_z():
+    d1 = Symbol("d1", positive=True)
+    d2 = Symbol("d2", positive=True)
+
+    X = FisherZ("x", d1, d2)
+    assert density(X)(x) == (2*d1**(d1/2)*d2**(d2/2)*(d1*exp(2*x) + d2)
+                             **(-d1/2 - d2/2)*exp(d1*x)/beta(d1/2, d2/2))
+
+def test_frechet():
+    a = Symbol("a", positive=True)
+    s = Symbol("s", positive=True)
+    m = Symbol("m", real=True)
+
+    X = Frechet("x", a, s=s, m=m)
+    assert density(X)(x) == a*((x - m)/s)**(-a - 1)*exp(-((x - m)/s)**(-a))/s
+    assert cdf(X)(x) == Piecewise((exp(-((-m + x)/s)**(-a)), m <= x), (0, True))
+
+@slow
+def test_gamma():
+    k = Symbol("k", positive=True)
+    theta = Symbol("theta", positive=True)
+
+    X = Gamma('x', k, theta)
+
+    # Tests characteristic function
+    assert characteristic_function(X)(x) == ((-I*theta*x + 1)**(-k))
+
+    assert density(X)(x) == x**(k - 1)*theta**(-k)*exp(-x/theta)/gamma(k)
+    assert cdf(X, meijerg=True)(z) == Piecewise(
+            (-k*lowergamma(k, 0)/gamma(k + 1) +
+                k*lowergamma(k, z/theta)/gamma(k + 1), z >= 0),
+            (0, True))
+
+    # assert simplify(variance(X)) == k*theta**2  # handled numerically below
+    assert E(X) == moment(X, 1)
+
+    k, theta = symbols('k theta', positive=True)
+    X = Gamma('x', k, theta)
+    assert E(X) == k*theta
+    assert variance(X) == k*theta**2
+    assert skewness(X).expand() == 2/sqrt(k)
+    assert kurtosis(X).expand() == 3 + 6/k
+
+    Y = Gamma('y', 2*k, 3*theta)
+    assert coskewness(X, theta*X + Y, k*X + Y).simplify() == \
+        2*531441**(-k)*sqrt(k)*theta*(3*3**(12*k) - 2*531441**k) \
+        /(sqrt(k**2 + 18)*sqrt(theta**2 + 18))
+
+def test_gamma_inverse():
+    a = Symbol("a", positive=True)
+    b = Symbol("b", positive=True)
+    X = GammaInverse("x", a, b)
+    assert density(X)(x) == x**(-a - 1)*b**a*exp(-b/x)/gamma(a)
+    assert cdf(X)(x) == Piecewise((uppergamma(a, b/x)/gamma(a), x > 0), (0, True))
+    assert characteristic_function(X)(x) == 2 * (-I*b*x)**(a/2) \
+            * besselk(a, 2*sqrt(b)*sqrt(-I*x))/gamma(a)
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+
+def test_gompertz():
+    b = Symbol("b", positive=True)
+    eta = Symbol("eta", positive=True)
+
+    X = Gompertz("x", b, eta)
+
+    assert density(X)(x) == b*eta*exp(eta)*exp(b*x)*exp(-eta*exp(b*x))
+    assert cdf(X)(x) == 1 - exp(eta)*exp(-eta*exp(b*x))
+    assert diff(cdf(X)(x), x) == density(X)(x)
+
+
+def test_gumbel():
+    beta = Symbol("beta", positive=True)
+    mu = Symbol("mu")
+    x = Symbol("x")
+    y = Symbol("y")
+    X = Gumbel("x", beta, mu)
+    Y = Gumbel("y", beta, mu, minimum=True)
+    assert density(X)(x).expand() == \
+    exp(mu/beta)*exp(-x/beta)*exp(-exp(mu/beta)*exp(-x/beta))/beta
+    assert density(Y)(y).expand() == \
+    exp(-mu/beta)*exp(y/beta)*exp(-exp(-mu/beta)*exp(y/beta))/beta
+    assert cdf(X)(x).expand() == \
+    exp(-exp(mu/beta)*exp(-x/beta))
+    assert characteristic_function(X)(x) == exp(I*mu*x)*gamma(-I*beta*x + 1)
+
+def test_kumaraswamy():
+    a = Symbol("a", positive=True)
+    b = Symbol("b", positive=True)
+
+    X = Kumaraswamy("x", a, b)
+    assert density(X)(x) == x**(a - 1)*a*b*(-x**a + 1)**(b - 1)
+    assert cdf(X)(x) == Piecewise((0, x < 0),
+                                (-(-x**a + 1)**b + 1, x <= 1),
+                                (1, True))
+
+
+def test_laplace():
+    mu = Symbol("mu")
+    b = Symbol("b", positive=True)
+
+    X = Laplace('x', mu, b)
+
+    #Tests characteristic_function
+    assert characteristic_function(X)(x) == (exp(I*mu*x)/(b**2*x**2 + 1))
+
+    assert density(X)(x) == exp(-Abs(x - mu)/b)/(2*b)
+    assert cdf(X)(x) == Piecewise((exp((-mu + x)/b)/2, mu > x),
+                            (-exp((mu - x)/b)/2 + 1, True))
+    X = Laplace('x', [1, 2], [[1, 0], [0, 1]])
+    assert isinstance(pspace(X).distribution, MultivariateLaplaceDistribution)
+
+def test_levy():
+    mu = Symbol("mu", real=True)
+    c = Symbol("c", positive=True)
+
+    X = Levy('x', mu, c)
+    assert X.pspace.domain.set == Interval(mu, oo)
+    assert density(X)(x) == sqrt(c/(2*pi))*exp(-c/(2*(x - mu)))/((x - mu)**(S.One + S.Half))
+    assert cdf(X)(x) == erfc(sqrt(c/(2*(x - mu))))
+
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    mu = Symbol("mu", real=False)
+    raises(ValueError, lambda: Levy('x',mu,c))
+
+    c = Symbol("c", nonpositive=True)
+    raises(ValueError, lambda: Levy('x',mu,c))
+
+    mu = Symbol("mu", real=True)
+    raises(ValueError, lambda: Levy('x',mu,c))
+
+def test_logcauchy():
+    mu = Symbol("mu", positive=True)
+    sigma = Symbol("sigma", positive=True)
+
+    X = LogCauchy("x", mu, sigma)
+
+    assert density(X)(x) == sigma/(x*pi*(sigma**2 + (-mu + log(x))**2))
+    assert cdf(X)(x) == atan((log(x) - mu)/sigma)/pi + S.Half
+
+
+def test_logistic():
+    mu = Symbol("mu", real=True)
+    s = Symbol("s", positive=True)
+    p = Symbol("p", positive=True)
+
+    X = Logistic('x', mu, s)
+
+    #Tests characteristics_function
+    assert characteristic_function(X)(x) == \
+           (Piecewise((pi*s*x*exp(I*mu*x)/sinh(pi*s*x), Ne(x, 0)), (1, True)))
+
+    assert density(X)(x) == exp((-x + mu)/s)/(s*(exp((-x + mu)/s) + 1)**2)
+    assert cdf(X)(x) == 1/(exp((mu - x)/s) + 1)
+    assert quantile(X)(p) == mu - s*log(-S.One + 1/p)
+
+def test_loglogistic():
+    a, b = symbols('a b')
+    assert LogLogistic('x', a, b)
+
+    a = Symbol('a', negative=True)
+    b = Symbol('b', positive=True)
+    raises(ValueError, lambda: LogLogistic('x', a, b))
+
+    a = Symbol('a', positive=True)
+    b = Symbol('b', negative=True)
+    raises(ValueError, lambda: LogLogistic('x', a, b))
+
+    a, b, z, p = symbols('a b z p', positive=True)
+    X = LogLogistic('x', a, b)
+    assert density(X)(z) == b*(z/a)**(b - 1)/(a*((z/a)**b + 1)**2)
+    assert cdf(X)(z) == 1/(1 + (z/a)**(-b))
+    assert quantile(X)(p) == a*(p/(1 - p))**(1/b)
+
+    # Expectation
+    assert E(X) == Piecewise((S.NaN, b <= 1), (pi*a/(b*sin(pi/b)), True))
+    b = symbols('b', prime=True) # b > 1
+    X = LogLogistic('x', a, b)
+    assert E(X) == pi*a/(b*sin(pi/b))
+    X = LogLogistic('x', 1, 2)
+    assert median(X) == FiniteSet(1)
+
+def test_logitnormal():
+    mu = Symbol('mu', real=True)
+    s = Symbol('s', positive=True)
+    X = LogitNormal('x', mu, s)
+    x = Symbol('x')
+
+    assert density(X)(x) == sqrt(2)*exp(-(-mu + log(x/(1 - x)))**2/(2*s**2))/(2*sqrt(pi)*s*x*(1 - x))
+    assert cdf(X)(x) == erf(sqrt(2)*(-mu + log(x/(1 - x)))/(2*s))/2 + S(1)/2
+
+def test_lognormal():
+    mean = Symbol('mu', real=True)
+    std = Symbol('sigma', positive=True)
+    X = LogNormal('x', mean, std)
+    # The sympy integrator can't do this too well
+    #assert E(X) == exp(mean+std**2/2)
+    #assert variance(X) == (exp(std**2)-1) * exp(2*mean + std**2)
+
+    # The sympy integrator can't do this too well
+    #assert E(X) ==
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+    mu = Symbol("mu", real=True)
+    sigma = Symbol("sigma", positive=True)
+
+    X = LogNormal('x', mu, sigma)
+    assert density(X)(x) == (sqrt(2)*exp(-(-mu + log(x))**2
+                                    /(2*sigma**2))/(2*x*sqrt(pi)*sigma))
+    # Tests cdf
+    assert cdf(X)(x) == Piecewise(
+                        (erf(sqrt(2)*(-mu + log(x))/(2*sigma))/2
+                        + S(1)/2, x > 0), (0, True))
+
+    X = LogNormal('x', 0, 1)  # Mean 0, standard deviation 1
+    assert density(X)(x) == sqrt(2)*exp(-log(x)**2/2)/(2*x*sqrt(pi))
+
+
+def test_Lomax():
+    a, l = symbols('a, l', negative=True)
+    raises(ValueError, lambda: Lomax('X', a, l))
+    a, l = symbols('a, l', real=False)
+    raises(ValueError, lambda: Lomax('X', a, l))
+
+    a, l = symbols('a, l', positive=True)
+    X = Lomax('X', a, l)
+    assert X.pspace.domain.set == Interval(0, oo)
+    assert density(X)(x) == a*(1 + x/l)**(-a - 1)/l
+    assert cdf(X)(x) == Piecewise((1 - (1 + x/l)**(-a), x >= 0), (0, True))
+    a = 3
+    X = Lomax('X', a, l)
+    assert E(X) == l/2
+    assert median(X) == FiniteSet(l*(-1 + 2**Rational(1, 3)))
+    assert variance(X) == 3*l**2/4
+
+
+def test_maxwell():
+    a = Symbol("a", positive=True)
+
+    X = Maxwell('x', a)
+
+    assert density(X)(x) == (sqrt(2)*x**2*exp(-x**2/(2*a**2))/
+        (sqrt(pi)*a**3))
+    assert E(X) == 2*sqrt(2)*a/sqrt(pi)
+    assert variance(X) == -8*a**2/pi + 3*a**2
+    assert cdf(X)(x) == erf(sqrt(2)*x/(2*a)) - sqrt(2)*x*exp(-x**2/(2*a**2))/(sqrt(pi)*a)
+    assert diff(cdf(X)(x), x) == density(X)(x)
+
+
+@slow
+def test_Moyal():
+    mu = Symbol('mu',real=False)
+    sigma = Symbol('sigma', positive=True)
+    raises(ValueError, lambda: Moyal('M',mu, sigma))
+
+    mu = Symbol('mu', real=True)
+    sigma = Symbol('sigma', negative=True)
+    raises(ValueError, lambda: Moyal('M',mu, sigma))
+
+    sigma = Symbol('sigma', positive=True)
+    M = Moyal('M', mu, sigma)
+    assert density(M)(z) == sqrt(2)*exp(-exp((mu - z)/sigma)/2
+                        - (-mu + z)/(2*sigma))/(2*sqrt(pi)*sigma)
+    assert cdf(M)(z).simplify() == 1 - erf(sqrt(2)*exp((mu - z)/(2*sigma))/2)
+    assert characteristic_function(M)(z) == 2**(-I*sigma*z)*exp(I*mu*z) \
+                        *gamma(-I*sigma*z + Rational(1, 2))/sqrt(pi)
+    assert E(M) == mu + EulerGamma*sigma + sigma*log(2)
+    assert moment_generating_function(M)(z) == 2**(-sigma*z)*exp(mu*z) \
+                        *gamma(-sigma*z + Rational(1, 2))/sqrt(pi)
+
+
+def test_nakagami():
+    mu = Symbol("mu", positive=True)
+    omega = Symbol("omega", positive=True)
+
+    X = Nakagami('x', mu, omega)
+    assert density(X)(x) == (2*x**(2*mu - 1)*mu**mu*omega**(-mu)
+                                *exp(-x**2*mu/omega)/gamma(mu))
+    assert simplify(E(X)) == (sqrt(mu)*sqrt(omega)
+                                            *gamma(mu + S.Half)/gamma(mu + 1))
+    assert simplify(variance(X)) == (
+    omega - omega*gamma(mu + S.Half)**2/(gamma(mu)*gamma(mu + 1)))
+    assert cdf(X)(x) == Piecewise(
+                                (lowergamma(mu, mu*x**2/omega)/gamma(mu), x > 0),
+                                (0, True))
+    X = Nakagami('x', 1, 1)
+    assert median(X) == FiniteSet(sqrt(log(2)))
+
+def test_gaussian_inverse():
+    # test for symbolic parameters
+    a, b = symbols('a b')
+    assert GaussianInverse('x', a, b)
+
+    # Inverse Gaussian distribution is also known as Wald distribution
+    # `GaussianInverse` can also be referred by the name `Wald`
+    a, b, z = symbols('a b z')
+    X = Wald('x', a, b)
+    assert density(X)(z) == sqrt(2)*sqrt(b/z**3)*exp(-b*(-a + z)**2/(2*a**2*z))/(2*sqrt(pi))
+
+    a, b = symbols('a b', positive=True)
+    z = Symbol('z', positive=True)
+
+    X = GaussianInverse('x', a, b)
+    assert density(X)(z) == sqrt(2)*sqrt(b)*sqrt(z**(-3))*exp(-b*(-a + z)**2/(2*a**2*z))/(2*sqrt(pi))
+    assert E(X) == a
+    assert variance(X).expand() == a**3/b
+    assert cdf(X)(z) == (S.Half - erf(sqrt(2)*sqrt(b)*(1 + z/a)/(2*sqrt(z)))/2)*exp(2*b/a) +\
+         erf(sqrt(2)*sqrt(b)*(-1 + z/a)/(2*sqrt(z)))/2 + S.Half
+
+    a = symbols('a', nonpositive=True)
+    raises(ValueError, lambda: GaussianInverse('x', a, b))
+
+    a = symbols('a', positive=True)
+    b = symbols('b', nonpositive=True)
+    raises(ValueError, lambda: GaussianInverse('x', a, b))
+
+def test_pareto():
+    xm, beta = symbols('xm beta', positive=True)
+    alpha = beta + 5
+    X = Pareto('x', xm, alpha)
+
+    dens = density(X)
+
+    #Tests cdf function
+    assert cdf(X)(x) == \
+           Piecewise((-x**(-beta - 5)*xm**(beta + 5) + 1, x >= xm), (0, True))
+
+    #Tests characteristic_function
+    assert characteristic_function(X)(x) == \
+           ((-I*x*xm)**(beta + 5)*(beta + 5)*uppergamma(-beta - 5, -I*x*xm))
+
+    assert dens(x) == x**(-(alpha + 1))*xm**(alpha)*(alpha)
+
+    assert simplify(E(X)) == alpha*xm/(alpha-1)
+
+    # computation of taylor series for MGF still too slow
+    #assert simplify(variance(X)) == xm**2*alpha / ((alpha-1)**2*(alpha-2))
+
+
+def test_pareto_numeric():
+    xm, beta = 3, 2
+    alpha = beta + 5
+    X = Pareto('x', xm, alpha)
+
+    assert E(X) == alpha*xm/S(alpha - 1)
+    assert variance(X) == xm**2*alpha / S((alpha - 1)**2*(alpha - 2))
+    assert median(X) == FiniteSet(3*2**Rational(1, 7))
+    # Skewness tests too slow. Try shortcutting function?
+
+
+def test_PowerFunction():
+    alpha = Symbol("alpha", nonpositive=True)
+    a, b = symbols('a, b', real=True)
+    raises (ValueError, lambda: PowerFunction('x', alpha, a, b))
+
+    a, b = symbols('a, b', real=False)
+    raises (ValueError, lambda: PowerFunction('x', alpha, a, b))
+
+    alpha = Symbol("alpha", positive=True)
+    a, b = symbols('a, b', real=True)
+    raises (ValueError, lambda: PowerFunction('x', alpha, 5, 2))
+
+    X = PowerFunction('X', 2, a, b)
+    assert density(X)(z) == (-2*a + 2*z)/(-a + b)**2
+    assert cdf(X)(z) == Piecewise((a**2/(a**2 - 2*a*b + b**2) -
+        2*a*z/(a**2 - 2*a*b + b**2) + z**2/(a**2 - 2*a*b + b**2), a <= z), (0, True))
+
+    X = PowerFunction('X', 2, 0, 1)
+    assert density(X)(z) == 2*z
+    assert cdf(X)(z) == Piecewise((z**2, z >= 0), (0,True))
+    assert E(X) == Rational(2,3)
+    assert P(X < 0) == 0
+    assert P(X < 1) == 1
+    assert median(X) == FiniteSet(1/sqrt(2))
+
+def test_raised_cosine():
+    mu = Symbol("mu", real=True)
+    s = Symbol("s", positive=True)
+
+    X = RaisedCosine("x", mu, s)
+
+    assert pspace(X).domain.set == Interval(mu - s, mu + s)
+    #Tests characteristics_function
+    assert characteristic_function(X)(x) == \
+           Piecewise((exp(-I*pi*mu/s)/2, Eq(x, -pi/s)), (exp(I*pi*mu/s)/2, Eq(x, pi/s)), (pi**2*exp(I*mu*x)*sin(s*x)/(s*x*(-s**2*x**2 + pi**2)), True))
+
+    assert density(X)(x) == (Piecewise(((cos(pi*(x - mu)/s) + 1)/(2*s),
+                          And(x <= mu + s, mu - s <= x)), (0, True)))
+
+
+def test_rayleigh():
+    sigma = Symbol("sigma", positive=True)
+
+    X = Rayleigh('x', sigma)
+
+    #Tests characteristic_function
+    assert characteristic_function(X)(x) == (-sqrt(2)*sqrt(pi)*sigma*x*(erfi(sqrt(2)*sigma*x/2) - I)*exp(-sigma**2*x**2/2)/2 + 1)
+
+    assert density(X)(x) ==  x*exp(-x**2/(2*sigma**2))/sigma**2
+    assert E(X) == sqrt(2)*sqrt(pi)*sigma/2
+    assert variance(X) == -pi*sigma**2/2 + 2*sigma**2
+    assert cdf(X)(x) == 1 - exp(-x**2/(2*sigma**2))
+    assert diff(cdf(X)(x), x) == density(X)(x)
+
+def test_reciprocal():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+
+    X = Reciprocal('x', a, b)
+    assert density(X)(x) == 1/(x*(-log(a) + log(b)))
+    assert cdf(X)(x) == Piecewise((log(a)/(log(a) - log(b)) - log(x)/(log(a) - log(b)), a <= x), (0, True))
+    X = Reciprocal('x', 5, 30)
+
+    assert E(X) == 25/(log(30) - log(5))
+    assert P(X < 4) == S.Zero
+    assert P(X < 20) == log(20) / (log(30) - log(5)) - log(5) / (log(30) - log(5))
+    assert cdf(X)(10) == log(10) / (log(30) - log(5)) - log(5) / (log(30) - log(5))
+
+    a = symbols('a', nonpositive=True)
+    raises(ValueError, lambda: Reciprocal('x', a, b))
+
+    a = symbols('a', positive=True)
+    b = symbols('b', positive=True)
+    raises(ValueError, lambda: Reciprocal('x', a + b, a))
+
+def test_shiftedgompertz():
+    b = Symbol("b", positive=True)
+    eta = Symbol("eta", positive=True)
+    X = ShiftedGompertz("x", b, eta)
+    assert density(X)(x) == b*(eta*(1 - exp(-b*x)) + 1)*exp(-b*x)*exp(-eta*exp(-b*x))
+
+
+def test_studentt():
+    nu = Symbol("nu", positive=True)
+
+    X = StudentT('x', nu)
+    assert density(X)(x) == (1 + x**2/nu)**(-nu/2 - S.Half)/(sqrt(nu)*beta(S.Half, nu/2))
+    assert cdf(X)(x) == S.Half + x*gamma(nu/2 + S.Half)*hyper((S.Half, nu/2 + S.Half),
+                                (Rational(3, 2),), -x**2/nu)/(sqrt(pi)*sqrt(nu)*gamma(nu/2))
+    raises(NotImplementedError, lambda: moment_generating_function(X))
+
+def test_trapezoidal():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    c = Symbol("c", real=True)
+    d = Symbol("d", real=True)
+
+    X = Trapezoidal('x', a, b, c, d)
+    assert density(X)(x) == Piecewise(((-2*a + 2*x)/((-a + b)*(-a - b + c + d)), (a <= x) & (x < b)),
+                                      (2/(-a - b + c + d), (b <= x) & (x < c)),
+                                      ((2*d - 2*x)/((-c + d)*(-a - b + c + d)), (c <= x) & (x <= d)),
+                                      (0, True))
+
+    X = Trapezoidal('x', 0, 1, 2, 3)
+    assert E(X) == Rational(3, 2)
+    assert variance(X) == Rational(5, 12)
+    assert P(X < 2) == Rational(3, 4)
+    assert median(X) == FiniteSet(Rational(3, 2))
+
+def test_triangular():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Symbol("c")
+
+    X = Triangular('x', a, b, c)
+    assert pspace(X).domain.set == Interval(a, b)
+    assert str(density(X)(x)) == ("Piecewise(((-2*a + 2*x)/((-a + b)*(-a + c)), (a <= x) & (c > x)), "
+    "(2/(-a + b), Eq(c, x)), ((2*b - 2*x)/((-a + b)*(b - c)), (b >= x) & (c < x)), (0, True))")
+
+    #Tests moment_generating_function
+    assert moment_generating_function(X)(x).expand() == \
+    ((-2*(-a + b)*exp(c*x) + 2*(-a + c)*exp(b*x) + 2*(b - c)*exp(a*x))/(x**2*(-a + b)*(-a + c)*(b - c))).expand()
+    assert str(characteristic_function(X)(x)) == \
+    '(2*(-a + b)*exp(I*c*x) - 2*(-a + c)*exp(I*b*x) - 2*(b - c)*exp(I*a*x))/(x**2*(-a + b)*(-a + c)*(b - c))'
+
+def test_quadratic_u():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+
+    X = QuadraticU("x", a, b)
+    Y = QuadraticU("x", 1, 2)
+
+    assert pspace(X).domain.set == Interval(a, b)
+    # Tests _moment_generating_function
+    assert moment_generating_function(Y)(1)  == -15*exp(2) + 27*exp(1)
+    assert moment_generating_function(Y)(2) == -9*exp(4)/2 + 21*exp(2)/2
+
+    assert characteristic_function(Y)(1) == 3*I*(-1 + 4*I)*exp(I*exp(2*I))
+    assert density(X)(x) == (Piecewise((12*(x - a/2 - b/2)**2/(-a + b)**3,
+                          And(x <= b, a <= x)), (0, True)))
+
+
+def test_uniform():
+    l = Symbol('l', real=True)
+    w = Symbol('w', positive=True)
+    X = Uniform('x', l, l + w)
+
+    assert E(X) == l + w/2
+    assert variance(X).expand() == w**2/12
+
+    # With numbers all is well
+    X = Uniform('x', 3, 5)
+    assert P(X < 3) == 0 and P(X > 5) == 0
+    assert P(X < 4) == P(X > 4) == S.Half
+    assert median(X) == FiniteSet(4)
+
+    z = Symbol('z')
+    p = density(X)(z)
+    assert p.subs(z, 3.7) == S.Half
+    assert p.subs(z, -1) == 0
+    assert p.subs(z, 6) == 0
+
+    c = cdf(X)
+    assert c(2) == 0 and c(3) == 0
+    assert c(Rational(7, 2)) == Rational(1, 4)
+    assert c(5) == 1 and c(6) == 1
+
+
+@XFAIL
+@slow
+def test_uniform_P():
+    """ This stopped working because SingleContinuousPSpace.compute_density no
+    longer calls integrate on a DiracDelta but rather just solves directly.
+    integrate used to call UniformDistribution.expectation which special-cased
+    subsed out the Min and Max terms that Uniform produces
+
+    I decided to regress on this class for general cleanliness (and I suspect
+    speed) of the algorithm.
+    """
+    l = Symbol('l', real=True)
+    w = Symbol('w', positive=True)
+    X = Uniform('x', l, l + w)
+    assert P(X < l) == 0 and P(X > l + w) == 0
+
+
+def test_uniformsum():
+    n = Symbol("n", integer=True)
+    _k = Dummy("k")
+    x = Symbol("x")
+
+    X = UniformSum('x', n)
+    res = Sum((-1)**_k*(-_k + x)**(n - 1)*binomial(n, _k), (_k, 0, floor(x)))/factorial(n - 1)
+    assert density(X)(x).dummy_eq(res)
+
+    #Tests set functions
+    assert X.pspace.domain.set == Interval(0, n)
+
+    #Tests the characteristic_function
+    assert characteristic_function(X)(x) == (-I*(exp(I*x) - 1)/x)**n
+
+    #Tests the moment_generating_function
+    assert moment_generating_function(X)(x) == ((exp(x) - 1)/x)**n
+
+
+def test_von_mises():
+    mu = Symbol("mu")
+    k = Symbol("k", positive=True)
+
+    X = VonMises("x", mu, k)
+    assert density(X)(x) == exp(k*cos(x - mu))/(2*pi*besseli(0, k))
+
+
+def test_weibull():
+    a, b = symbols('a b', positive=True)
+    # FIXME: simplify(E(X)) seems to hang without extended_positive=True
+    # On a Linux machine this had a rapid memory leak...
+    # a, b = symbols('a b', positive=True)
+    X = Weibull('x', a, b)
+
+    assert E(X).expand() == a * gamma(1 + 1/b)
+    assert variance(X).expand() == (a**2 * gamma(1 + 2/b) - E(X)**2).expand()
+    assert simplify(skewness(X)) == (2*gamma(1 + 1/b)**3 - 3*gamma(1 + 1/b)*gamma(1 + 2/b) + gamma(1 + 3/b))/(-gamma(1 + 1/b)**2 + gamma(1 + 2/b))**Rational(3, 2)
+    assert simplify(kurtosis(X)) == (-3*gamma(1 + 1/b)**4 +\
+        6*gamma(1 + 1/b)**2*gamma(1 + 2/b) - 4*gamma(1 + 1/b)*gamma(1 + 3/b) + gamma(1 + 4/b))/(gamma(1 + 1/b)**2 - gamma(1 + 2/b))**2
+
+def test_weibull_numeric():
+    # Test for integers and rationals
+    a = 1
+    bvals = [S.Half, 1, Rational(3, 2), 5]
+    for b in bvals:
+        X = Weibull('x', a, b)
+        assert simplify(E(X)) == expand_func(a * gamma(1 + 1/S(b)))
+        assert simplify(variance(X)) == simplify(
+            a**2 * gamma(1 + 2/S(b)) - E(X)**2)
+        # Not testing Skew... it's slow with int/frac values > 3/2
+
+
+def test_wignersemicircle():
+    R = Symbol("R", positive=True)
+
+    X = WignerSemicircle('x', R)
+    assert pspace(X).domain.set == Interval(-R, R)
+    assert density(X)(x) == 2*sqrt(-x**2 + R**2)/(pi*R**2)
+    assert E(X) == 0
+
+
+    #Tests ChiNoncentralDistribution
+    assert characteristic_function(X)(x) == \
+           Piecewise((2*besselj(1, R*x)/(R*x), Ne(x, 0)), (1, True))
+
+
+def test_input_value_assertions():
+    a, b = symbols('a b')
+    p, q = symbols('p q', positive=True)
+    m, n = symbols('m n', positive=False, real=True)
+
+    raises(ValueError, lambda: Normal('x', 3, 0))
+    raises(ValueError, lambda: Normal('x', m, n))
+    Normal('X', a, p)  # No error raised
+    raises(ValueError, lambda: Exponential('x', m))
+    Exponential('Ex', p)  # No error raised
+    for fn in [Pareto, Weibull, Beta, Gamma]:
+        raises(ValueError, lambda: fn('x', m, p))
+        raises(ValueError, lambda: fn('x', p, n))
+        fn('x', p, q)  # No error raised
+
+
+def test_unevaluated():
+    X = Normal('x', 0, 1)
+    k = Dummy('k')
+    expr1 = Integral(sqrt(2)*k*exp(-k**2/2)/(2*sqrt(pi)), (k, -oo, oo))
+    expr2 = Integral(sqrt(2)*exp(-k**2/2)/(2*sqrt(pi)), (k, 0, oo))
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert E(X, evaluate=False).rewrite(Integral).dummy_eq(expr1)
+        assert E(X + 1, evaluate=False).rewrite(Integral).dummy_eq(expr1 + 1)
+        assert P(X > 0, evaluate=False).rewrite(Integral).dummy_eq(expr2)
+
+    assert P(X > 0, X**2 < 1) == S.Half
+
+
+def test_probability_unevaluated():
+    T = Normal('T', 30, 3)
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert type(P(T > 33, evaluate=False)) == Probability
+
+
+def test_density_unevaluated():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 2)
+    assert isinstance(density(X+Y, evaluate=False)(z), Integral)
+
+
+def test_NormalDistribution():
+    nd = NormalDistribution(0, 1)
+    x = Symbol('x')
+    assert nd.cdf(x) == erf(sqrt(2)*x/2)/2 + S.Half
+    assert nd.expectation(1, x) == 1
+    assert nd.expectation(x, x) == 0
+    assert nd.expectation(x**2, x) == 1
+    #Test issue 10076
+    a = SingleContinuousPSpace(x, NormalDistribution(2, 4))
+    _z = Dummy('_z')
+
+    expected1 = Integral(sqrt(2)*exp(-(_z - 2)**2/32)/(8*sqrt(pi)),(_z, -oo, 1))
+    assert a.probability(x < 1, evaluate=False).dummy_eq(expected1) is True
+
+    expected2 = Integral(sqrt(2)*exp(-(_z - 2)**2/32)/(8*sqrt(pi)),(_z, 1, oo))
+    assert a.probability(x > 1, evaluate=False).dummy_eq(expected2) is True
+
+    b = SingleContinuousPSpace(x, NormalDistribution(1, 9))
+
+    expected3 = Integral(sqrt(2)*exp(-(_z - 1)**2/162)/(18*sqrt(pi)),(_z, 6, oo))
+    assert b.probability(x > 6, evaluate=False).dummy_eq(expected3) is True
+
+    expected4 = Integral(sqrt(2)*exp(-(_z - 1)**2/162)/(18*sqrt(pi)),(_z, -oo, 6))
+    assert b.probability(x < 6, evaluate=False).dummy_eq(expected4) is True
+
+
+def test_random_parameters():
+    mu = Normal('mu', 2, 3)
+    meas = Normal('T', mu, 1)
+    assert density(meas, evaluate=False)(z)
+    assert isinstance(pspace(meas), CompoundPSpace)
+    X = Normal('x', [1, 2], [[1, 0], [0, 1]])
+    assert isinstance(pspace(X).distribution, MultivariateNormalDistribution)
+    assert density(meas)(z).simplify() == sqrt(5)*exp(-z**2/20 + z/5 - S(1)/5)/(10*sqrt(pi))
+
+
+def test_random_parameters_given():
+    mu = Normal('mu', 2, 3)
+    meas = Normal('T', mu, 1)
+    assert given(meas, Eq(mu, 5)) == Normal('T', 5, 1)
+
+
+def test_conjugate_priors():
+    mu = Normal('mu', 2, 3)
+    x = Normal('x', mu, 1)
+    assert isinstance(simplify(density(mu, Eq(x, y), evaluate=False)(z)),
+            Mul)
+
+
+def test_difficult_univariate():
+    """ Since using solve in place of deltaintegrate we're able to perform
+    substantially more complex density computations on single continuous random
+    variables """
+    x = Normal('x', 0, 1)
+    assert density(x**3)
+    assert density(exp(x**2))
+    assert density(log(x))
+
+
+def test_issue_10003():
+    X = Exponential('x', 3)
+    G = Gamma('g', 1, 2)
+    assert P(X < -1) is S.Zero
+    assert P(G < -1) is S.Zero
+
+
+def test_precomputed_cdf():
+    x = symbols("x", real=True)
+    mu = symbols("mu", real=True)
+    sigma, xm, alpha = symbols("sigma xm alpha", positive=True)
+    n = symbols("n", integer=True, positive=True)
+    distribs = [
+            Normal("X", mu, sigma),
+            Pareto("P", xm, alpha),
+            ChiSquared("C", n),
+            Exponential("E", sigma),
+            # LogNormal("L", mu, sigma),
+    ]
+    for X in distribs:
+        compdiff = cdf(X)(x) - simplify(X.pspace.density.compute_cdf()(x))
+        compdiff = simplify(compdiff.rewrite(erfc))
+        assert compdiff == 0
+
+
+@slow
+def test_precomputed_characteristic_functions():
+    import mpmath
+
+    def test_cf(dist, support_lower_limit, support_upper_limit):
+        pdf = density(dist)
+        t = Symbol('t')
+
+        # first function is the hardcoded CF of the distribution
+        cf1 = lambdify([t], characteristic_function(dist)(t), 'mpmath')
+
+        # second function is the Fourier transform of the density function
+        f = lambdify([x, t], pdf(x)*exp(I*x*t), 'mpmath')
+        cf2 = lambda t: mpmath.quad(lambda x: f(x, t), [support_lower_limit, support_upper_limit], maxdegree=10)
+
+        # compare the two functions at various points
+        for test_point in [2, 5, 8, 11]:
+            n1 = cf1(test_point)
+            n2 = cf2(test_point)
+
+            assert abs(re(n1) - re(n2)) < 1e-12
+            assert abs(im(n1) - im(n2)) < 1e-12
+
+    test_cf(Beta('b', 1, 2), 0, 1)
+    test_cf(Chi('c', 3), 0, mpmath.inf)
+    test_cf(ChiSquared('c', 2), 0, mpmath.inf)
+    test_cf(Exponential('e', 6), 0, mpmath.inf)
+    test_cf(Logistic('l', 1, 2), -mpmath.inf, mpmath.inf)
+    test_cf(Normal('n', -1, 5), -mpmath.inf, mpmath.inf)
+    test_cf(RaisedCosine('r', 3, 1), 2, 4)
+    test_cf(Rayleigh('r', 0.5), 0, mpmath.inf)
+    test_cf(Uniform('u', -1, 1), -1, 1)
+    test_cf(WignerSemicircle('w', 3), -3, 3)
+
+
+def test_long_precomputed_cdf():
+    x = symbols("x", real=True)
+    distribs = [
+            Arcsin("A", -5, 9),
+            Dagum("D", 4, 10, 3),
+            Erlang("E", 14, 5),
+            Frechet("F", 2, 6, -3),
+            Gamma("G", 2, 7),
+            GammaInverse("GI", 3, 5),
+            Kumaraswamy("K", 6, 8),
+            Laplace("LA", -5, 4),
+            Logistic("L", -6, 7),
+            Nakagami("N", 2, 7),
+            StudentT("S", 4)
+            ]
+    for distr in distribs:
+        for _ in range(5):
+            assert tn(diff(cdf(distr)(x), x), density(distr)(x), x, a=0, b=0, c=1, d=0)
+
+    US = UniformSum("US", 5)
+    pdf01 = density(US)(x).subs(floor(x), 0).doit()   # pdf on (0, 1)
+    cdf01 = cdf(US, evaluate=False)(x).subs(floor(x), 0).doit()   # cdf on (0, 1)
+    assert tn(diff(cdf01, x), pdf01, x, a=0, b=0, c=1, d=0)
+
+
+def test_issue_13324():
+    X = Uniform('X', 0, 1)
+    assert E(X, X > S.Half) == Rational(3, 4)
+    assert E(X, X > 0) == S.Half
+
+def test_issue_20756():
+    X = Uniform('X', -1, +1)
+    Y = Uniform('Y', -1, +1)
+    assert E(X * Y) == S.Zero
+    assert E(X * ((Y + 1) - 1)) == S.Zero
+    assert E(Y * (X*(X + 1) - X*X)) == S.Zero
+
+def test_FiniteSet_prob():
+    E = Exponential('E', 3)
+    N = Normal('N', 5, 7)
+    assert P(Eq(E, 1)) is S.Zero
+    assert P(Eq(N, 2)) is S.Zero
+    assert P(Eq(N, x)) is S.Zero
+
+def test_prob_neq():
+    E = Exponential('E', 4)
+    X = ChiSquared('X', 4)
+    assert P(Ne(E, 2)) == 1
+    assert P(Ne(X, 4)) == 1
+    assert P(Ne(X, 4)) == 1
+    assert P(Ne(X, 5)) == 1
+    assert P(Ne(E, x)) == 1
+
+def test_union():
+    N = Normal('N', 3, 2)
+    assert simplify(P(N**2 - N > 2)) == \
+        -erf(sqrt(2))/2 - erfc(sqrt(2)/4)/2 + Rational(3, 2)
+    assert simplify(P(N**2 - 4 > 0)) == \
+        -erf(5*sqrt(2)/4)/2 - erfc(sqrt(2)/4)/2 + Rational(3, 2)
+
+def test_Or():
+    N = Normal('N', 0, 1)
+    assert simplify(P(Or(N > 2, N < 1))) == \
+        -erf(sqrt(2))/2 - erfc(sqrt(2)/2)/2 + Rational(3, 2)
+    assert P(Or(N < 0, N < 1)) == P(N < 1)
+    assert P(Or(N > 0, N < 0)) == 1
+
+
+def test_conditional_eq():
+    E = Exponential('E', 1)
+    assert P(Eq(E, 1), Eq(E, 1)) == 1
+    assert P(Eq(E, 1), Eq(E, 2)) == 0
+    assert P(E > 1, Eq(E, 2)) == 1
+    assert P(E < 1, Eq(E, 2)) == 0
+
+def test_ContinuousDistributionHandmade():
+    x = Symbol('x')
+    z = Dummy('z')
+    dens = Lambda(x, Piecewise((S.Half, (0<=x)&(x<1)), (0, (x>=1)&(x<2)),
+        (S.Half, (x>=2)&(x<3)), (0, True)))
+    dens = ContinuousDistributionHandmade(dens, set=Interval(0, 3))
+    space = SingleContinuousPSpace(z, dens)
+    assert dens.pdf == Lambda(x, Piecewise((S(1)/2, (x >= 0) & (x < 1)),
+        (0, (x >= 1) & (x < 2)), (S(1)/2, (x >= 2) & (x < 3)), (0, True)))
+    assert median(space.value) == Interval(1, 2)
+    assert E(space.value) == Rational(3, 2)
+    assert variance(space.value) == Rational(13, 12)
+
+
+def test_issue_16318():
+    # test compute_expectation function of the SingleContinuousDomain
+    N = SingleContinuousDomain(x, Interval(0, 1))
+    raises(ValueError, lambda: SingleContinuousDomain.compute_expectation(N, x+1, {x, y}))
+
+def test_compute_density():
+    X = Normal('X', 0, Symbol("sigma")**2)
+    raises(ValueError, lambda: density(X**5 + X))

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_discrete_rv.py

@@ -0,0 +1,312 @@
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import 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.zeta_functions import zeta
+from sympy.sets.sets import FiniteSet
+from sympy.simplify.simplify import simplify
+from sympy.utilities.lambdify import lambdify
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.exponential import exp
+from sympy.logic.boolalg import Or
+from sympy.sets.fancysets import Range
+from sympy.stats import (P, E, variance, density, characteristic_function,
+                         where, moment_generating_function, skewness, cdf,
+                         kurtosis, coskewness)
+from sympy.stats.drv_types import (PoissonDistribution, GeometricDistribution,
+                                   FlorySchulz, Poisson, Geometric, Hermite, Logarithmic,
+                                    NegativeBinomial, Skellam, YuleSimon, Zeta,
+                                    DiscreteRV)
+from sympy.testing.pytest import slow, nocache_fail, raises, skip
+from sympy.stats.symbolic_probability import Expectation
+from sympy.functions.combinatorial.factorials import FallingFactorial
+
+x = Symbol('x')
+
+
+def test_PoissonDistribution():
+    l = 3
+    p = PoissonDistribution(l)
+    assert abs(p.cdf(10).evalf() - 1) < .001
+    assert abs(p.cdf(10.4).evalf() - 1) < .001
+    assert p.expectation(x, x) == l
+    assert p.expectation(x**2, x) - p.expectation(x, x)**2 == l
+
+
+def test_Poisson():
+    l = 3
+    x = Poisson('x', l)
+    assert E(x) == l
+    assert E(2*x) == 2*l
+    assert variance(x) == l
+    assert density(x) == PoissonDistribution(l)
+    assert isinstance(E(x, evaluate=False), Expectation)
+    assert isinstance(E(2*x, evaluate=False), Expectation)
+    # issue 8248
+    assert x.pspace.compute_expectation(1) == 1
+    # issue 27344
+    try:
+        import numpy as np
+    except ImportError:
+        skip("numpy not installed")
+    y = Poisson('y', np.float64(4.72544290380919e-11))
+    assert E(y) == 4.72544290380919e-11
+    y = Poisson('y', np.float64(4.725442903809197e-11))
+    assert E(y) == 4.725442903809197e-11
+    l2 = 5
+    z = Poisson('z', l2)
+    assert E(z) == l2
+    assert E(FallingFactorial(z, 3)) == l2**3
+    assert E(z**2) == l2 + l2**2
+
+
+def test_FlorySchulz():
+    a = Symbol("a")
+    z = Symbol("z")
+    x = FlorySchulz('x', a)
+    assert E(x) == (2 - a)/a
+    assert (variance(x) - 2*(1 - a)/a**2).simplify() == S(0)
+    assert density(x)(z) == a**2*z*(1 - a)**(z - 1)
+
+
+@slow
+def test_GeometricDistribution():
+    p = S.One / 5
+    d = GeometricDistribution(p)
+    assert d.expectation(x, x) == 1/p
+    assert d.expectation(x**2, x) - d.expectation(x, x)**2 == (1-p)/p**2
+    assert abs(d.cdf(20000).evalf() - 1) < .001
+    assert abs(d.cdf(20000.8).evalf() - 1) < .001
+    G = Geometric('G', p=S(1)/4)
+    assert cdf(G)(S(7)/2) == P(G <= S(7)/2)
+
+    X = Geometric('X', Rational(1, 5))
+    Y = Geometric('Y', Rational(3, 10))
+    assert coskewness(X, X + Y, X + 2*Y).simplify() == sqrt(230)*Rational(81, 1150)
+
+
+def test_Hermite():
+    a1 = Symbol("a1", positive=True)
+    a2 = Symbol("a2", negative=True)
+    raises(ValueError, lambda: Hermite("H", a1, a2))
+
+    a1 = Symbol("a1", negative=True)
+    a2 = Symbol("a2", positive=True)
+    raises(ValueError, lambda: Hermite("H", a1, a2))
+
+    a1 = Symbol("a1", positive=True)
+    x = Symbol("x")
+    H = Hermite("H", a1, a2)
+    assert moment_generating_function(H)(x) == exp(a1*(exp(x) - 1)
+                                            + a2*(exp(2*x) - 1))
+    assert characteristic_function(H)(x) == exp(a1*(exp(I*x) - 1)
+                                            + a2*(exp(2*I*x) - 1))
+    assert E(H) == a1 + 2*a2
+
+    H = Hermite("H", a1=5, a2=4)
+    assert density(H)(2) == 33*exp(-9)/2
+    assert E(H) == 13
+    assert variance(H) == 21
+    assert kurtosis(H) == Rational(464,147)
+    assert skewness(H) == 37*sqrt(21)/441
+
+def test_Logarithmic():
+    p = S.Half
+    x = Logarithmic('x', p)
+    assert E(x) == -p / ((1 - p) * log(1 - p))
+    assert variance(x) == -1/log(2)**2 + 2/log(2)
+    assert E(2*x**2 + 3*x + 4) == 4 + 7 / log(2)
+    assert isinstance(E(x, evaluate=False), Expectation)
+
+
+@nocache_fail
+def test_negative_binomial():
+    r = 5
+    p = S.One / 3
+    x = NegativeBinomial('x', r, p)
+    assert E(x) == r * (1 - p) / p
+    # This hangs when run with the cache disabled:
+    assert variance(x) == r * (1 - p) / p**2
+    assert E(x**5 + 2*x + 3) == E(x**5) + 2*E(x) + 3 == Rational(796473, 1)
+    assert isinstance(E(x, evaluate=False), Expectation)
+
+
+def test_skellam():
+    mu1 = Symbol('mu1')
+    mu2 = Symbol('mu2')
+    z = Symbol('z')
+    X = Skellam('x', mu1, mu2)
+
+    assert density(X)(z) == (mu1/mu2)**(z/2) * \
+        exp(-mu1 - mu2)*besseli(z, 2*sqrt(mu1*mu2))
+    assert skewness(X).expand() == mu1/(mu1*sqrt(mu1 + mu2) + mu2 *
+                sqrt(mu1 + mu2)) - mu2/(mu1*sqrt(mu1 + mu2) + mu2*sqrt(mu1 + mu2))
+    assert variance(X).expand() == mu1 + mu2
+    assert E(X) == mu1 - mu2
+    assert characteristic_function(X)(z) == exp(
+        mu1*exp(I*z) - mu1 - mu2 + mu2*exp(-I*z))
+    assert moment_generating_function(X)(z) == exp(
+        mu1*exp(z) - mu1 - mu2 + mu2*exp(-z))
+
+
+def test_yule_simon():
+    from sympy.core.singleton import S
+    rho = S(3)
+    x = YuleSimon('x', rho)
+    assert simplify(E(x)) == rho / (rho - 1)
+    assert simplify(variance(x)) == rho**2 / ((rho - 1)**2 * (rho - 2))
+    assert isinstance(E(x, evaluate=False), Expectation)
+    # To test the cdf function
+    assert cdf(x)(x) == Piecewise((-beta(floor(x), 4)*floor(x) + 1, x >= 1), (0, True))
+
+
+def test_zeta():
+    s = S(5)
+    x = Zeta('x', s)
+    assert E(x) == zeta(s-1) / zeta(s)
+    assert simplify(variance(x)) == (
+        zeta(s) * zeta(s-2) - zeta(s-1)**2) / zeta(s)**2
+
+
+def test_discrete_probability():
+    X = Geometric('X', Rational(1, 5))
+    Y = Poisson('Y', 4)
+    G = Geometric('e', x)
+    assert P(Eq(X, 3)) == Rational(16, 125)
+    assert P(X < 3) == Rational(9, 25)
+    assert P(X > 3) == Rational(64, 125)
+    assert P(X >= 3) == Rational(16, 25)
+    assert P(X <= 3) == Rational(61, 125)
+    assert P(Ne(X, 3)) == Rational(109, 125)
+    assert P(Eq(Y, 3)) == 32*exp(-4)/3
+    assert P(Y < 3) == 13*exp(-4)
+    assert P(Y > 3).equals(32*(Rational(-71, 32) + 3*exp(4)/32)*exp(-4)/3)
+    assert P(Y >= 3).equals(32*(Rational(-39, 32) + 3*exp(4)/32)*exp(-4)/3)
+    assert P(Y <= 3) == 71*exp(-4)/3
+    assert P(Ne(Y, 3)).equals(
+        13*exp(-4) + 32*(Rational(-71, 32) + 3*exp(4)/32)*exp(-4)/3)
+    assert P(X < S.Infinity) is S.One
+    assert P(X > S.Infinity) is S.Zero
+    assert P(G < 3) == x*(2-x)
+    assert P(Eq(G, 3)) == x*(-x + 1)**2
+
+
+def test_DiscreteRV():
+    p = S(1)/2
+    x = Symbol('x', integer=True, positive=True)
+    pdf = p*(1 - p)**(x - 1) # pdf of Geometric Distribution
+    D = DiscreteRV(x, pdf, set=S.Naturals, check=True)
+    assert E(D) == E(Geometric('G', S(1)/2)) == 2
+    assert P(D > 3) == S(1)/8
+    assert D.pspace.domain.set == S.Naturals
+    raises(ValueError, lambda: DiscreteRV(x, x, FiniteSet(*range(4)), check=True))
+
+    # purposeful invalid pmf but it should not raise since check=False
+    # see test_drv_types.test_ContinuousRV for explanation
+    X = DiscreteRV(x, 1/x, S.Naturals)
+    assert P(X < 2) == 1
+    assert E(X) == oo
+
+def test_precomputed_characteristic_functions():
+    import mpmath
+
+    def test_cf(dist, support_lower_limit, support_upper_limit):
+        pdf = density(dist)
+        t = S('t')
+        x = S('x')
+
+        # first function is the hardcoded CF of the distribution
+        cf1 = lambdify([t], characteristic_function(dist)(t), 'mpmath')
+
+        # second function is the Fourier transform of the density function
+        f = lambdify([x, t], pdf(x)*exp(I*x*t), 'mpmath')
+        cf2 = lambda t: mpmath.nsum(lambda x: f(x, t), [
+            support_lower_limit, support_upper_limit], maxdegree=10)
+
+        # compare the two functions at various points
+        for test_point in [2, 5, 8, 11]:
+            n1 = cf1(test_point)
+            n2 = cf2(test_point)
+
+            assert abs(re(n1) - re(n2)) < 1e-12
+            assert abs(im(n1) - im(n2)) < 1e-12
+
+    test_cf(Geometric('g', Rational(1, 3)), 1, mpmath.inf)
+    test_cf(Logarithmic('l', Rational(1, 5)), 1, mpmath.inf)
+    test_cf(NegativeBinomial('n', 5, Rational(1, 7)), 0, mpmath.inf)
+    test_cf(Poisson('p', 5), 0, mpmath.inf)
+    test_cf(YuleSimon('y', 5), 1, mpmath.inf)
+    test_cf(Zeta('z', 5), 1, mpmath.inf)
+
+
+def test_moment_generating_functions():
+    t = S('t')
+
+    geometric_mgf = moment_generating_function(Geometric('g', S.Half))(t)
+    assert geometric_mgf.diff(t).subs(t, 0) == 2
+
+    logarithmic_mgf = moment_generating_function(Logarithmic('l', S.Half))(t)
+    assert logarithmic_mgf.diff(t).subs(t, 0) == 1/log(2)
+
+    negative_binomial_mgf = moment_generating_function(
+        NegativeBinomial('n', 5, Rational(1, 3)))(t)
+    assert negative_binomial_mgf.diff(t).subs(t, 0) == Rational(10, 1)
+
+    poisson_mgf = moment_generating_function(Poisson('p', 5))(t)
+    assert poisson_mgf.diff(t).subs(t, 0) == 5
+
+    skellam_mgf = moment_generating_function(Skellam('s', 1, 1))(t)
+    assert skellam_mgf.diff(t).subs(
+        t, 2) == (-exp(-2) + exp(2))*exp(-2 + exp(-2) + exp(2))
+
+    yule_simon_mgf = moment_generating_function(YuleSimon('y', 3))(t)
+    assert simplify(yule_simon_mgf.diff(t).subs(t, 0)) == Rational(3, 2)
+
+    zeta_mgf = moment_generating_function(Zeta('z', 5))(t)
+    assert zeta_mgf.diff(t).subs(t, 0) == pi**4/(90*zeta(5))
+
+
+def test_Or():
+    X = Geometric('X', S.Half)
+    assert P(Or(X < 3, X > 4)) == Rational(13, 16)
+    assert P(Or(X > 2, X > 1)) == P(X > 1)
+    assert P(Or(X >= 3, X < 3)) == 1
+
+
+def test_where():
+    X = Geometric('X', Rational(1, 5))
+    Y = Poisson('Y', 4)
+    assert where(X**2 > 4).set == Range(3, S.Infinity, 1)
+    assert where(X**2 >= 4).set == Range(2, S.Infinity, 1)
+    assert where(Y**2 < 9).set == Range(0, 3, 1)
+    assert where(Y**2 <= 9).set == Range(0, 4, 1)
+
+
+def test_conditional():
+    X = Geometric('X', Rational(2, 3))
+    Y = Poisson('Y', 3)
+    assert P(X > 2, X > 3) == 1
+    assert P(X > 3, X > 2) == Rational(1, 3)
+    assert P(Y > 2, Y < 2) == 0
+    assert P(Eq(Y, 3), Y >= 0) == 9*exp(-3)/2
+    assert P(Eq(Y, 3), Eq(Y, 2)) == 0
+    assert P(X < 2, Eq(X, 2)) == 0
+    assert P(X > 2, Eq(X, 3)) == 1
+
+
+def test_product_spaces():
+    X1 = Geometric('X1', S.Half)
+    X2 = Geometric('X2', Rational(1, 3))
+    assert str(P(X1 + X2 < 3).rewrite(Sum)) == (
+        "Sum(Piecewise((1/(4*2**n), n >= -1), (0, True)), (n, -oo, -1))/3")
+    assert str(P(X1 + X2 > 3).rewrite(Sum)) == (
+        'Sum(Piecewise((2**(X2 - n - 2)*(2/3)**(X2 - 1)/6, '
+        'X2 - n <= 2), (0, True)), (X2, 1, oo), (n, 1, oo))')
+    assert P(Eq(X1 + X2, 3)) == Rational(1, 12)

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_error_prop.py

@@ -0,0 +1,60 @@
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.stats.error_prop import variance_prop
+from sympy.stats.symbolic_probability import (RandomSymbol, Variance,
+        Covariance)
+
+
+def test_variance_prop():
+    x, y, z = symbols('x y z')
+    phi, t = consts = symbols('phi t')
+    a = RandomSymbol(x)
+    var_x = Variance(a)
+    var_y = Variance(RandomSymbol(y))
+    var_z = Variance(RandomSymbol(z))
+    f = Function('f')(x)
+    cases = {
+        x + y: var_x + var_y,
+        a + y: var_x + var_y,
+        x + y + z: var_x + var_y + var_z,
+        2*x: 4*var_x,
+        x*y: var_x*y**2 + var_y*x**2,
+        1/x: var_x/x**4,
+        x/y: (var_x*y**2 + var_y*x**2)/y**4,
+        exp(x): var_x*exp(2*x),
+        exp(2*x): 4*var_x*exp(4*x),
+        exp(-x*t): t**2*var_x*exp(-2*t*x),
+        f: Variance(f),
+        }
+    for inp, out in cases.items():
+        obs = variance_prop(inp, consts=consts)
+        assert out == obs
+
+def test_variance_prop_with_covar():
+    x, y, z = symbols('x y z')
+    phi, t = consts = symbols('phi t')
+    a = RandomSymbol(x)
+    var_x = Variance(a)
+    b = RandomSymbol(y)
+    var_y = Variance(b)
+    c = RandomSymbol(z)
+    var_z = Variance(c)
+    covar_x_y = Covariance(a, b)
+    covar_x_z = Covariance(a, c)
+    covar_y_z = Covariance(b, c)
+    cases = {
+        x + y: var_x + var_y + 2*covar_x_y,
+        a + y: var_x + var_y + 2*covar_x_y,
+        x + y + z: var_x + var_y + var_z + \
+                   2*covar_x_y + 2*covar_x_z + 2*covar_y_z,
+        2*x: 4*var_x,
+        x*y: var_x*y**2 + var_y*x**2 + 2*covar_x_y/(x*y),
+        1/x: var_x/x**4,
+        exp(x): var_x*exp(2*x),
+        exp(2*x): 4*var_x*exp(4*x),
+        exp(-x*t): t**2*var_x*exp(-2*t*x),
+        }
+    for inp, out in cases.items():
+        obs = variance_prop(inp, consts=consts, include_covar=True)
+        assert out == obs

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_finite_rv.py

@@ -0,0 +1,509 @@
+from sympy.concrete.summations import Sum
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational, nan)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.combinatorial.numbers import harmonic
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cos
+from sympy.functions.special.beta_functions import beta
+from sympy.logic.boolalg import (And, Or)
+from sympy.polys.polytools import cancel
+from sympy.sets.sets import FiniteSet
+from sympy.simplify.simplify import simplify
+from sympy.matrices import Matrix
+from sympy.stats import (DiscreteUniform, Die, Bernoulli, Coin, Binomial, BetaBinomial,
+                         Hypergeometric, Rademacher, IdealSoliton, RobustSoliton, P, E, variance,
+                         covariance, skewness, density, where, FiniteRV, pspace, cdf,
+                         correlation, moment, cmoment, smoment, characteristic_function,
+                         moment_generating_function, quantile,  kurtosis, median, coskewness)
+from sympy.stats.frv_types import DieDistribution, BinomialDistribution, \
+    HypergeometricDistribution
+from sympy.stats.rv import Density
+from sympy.testing.pytest import raises
+
+
+def BayesTest(A, B):
+    assert P(A, B) == P(And(A, B)) / P(B)
+    assert P(A, B) == P(B, A) * P(A) / P(B)
+
+
+def test_discreteuniform():
+    # Symbolic
+    a, b, c, t = symbols('a b c t')
+    X = DiscreteUniform('X', [a, b, c])
+
+    assert E(X) == (a + b + c)/3
+    assert simplify(variance(X)
+                    - ((a**2 + b**2 + c**2)/3 - (a/3 + b/3 + c/3)**2)) == 0
+    assert P(Eq(X, a)) == P(Eq(X, b)) == P(Eq(X, c)) == S('1/3')
+
+    Y = DiscreteUniform('Y', range(-5, 5))
+
+    # Numeric
+    assert E(Y) == S('-1/2')
+    assert variance(Y) == S('33/4')
+    assert median(Y) == FiniteSet(-1, 0)
+
+    for x in range(-5, 5):
+        assert P(Eq(Y, x)) == S('1/10')
+        assert P(Y <= x) == S(x + 6)/10
+        assert P(Y >= x) == S(5 - x)/10
+
+    assert dict(density(Die('D', 6)).items()) == \
+           dict(density(DiscreteUniform('U', range(1, 7))).items())
+
+    assert characteristic_function(X)(t) == exp(I*a*t)/3 + exp(I*b*t)/3 + exp(I*c*t)/3
+    assert moment_generating_function(X)(t) == exp(a*t)/3 + exp(b*t)/3 + exp(c*t)/3
+    # issue 18611
+    raises(ValueError, lambda: DiscreteUniform('Z', [a, a, a, b, b, c]))
+
+def test_dice():
+    # TODO: Make iid method!
+    X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6)
+    a, b, t, p = symbols('a b t p')
+
+    assert E(X) == 3 + S.Half
+    assert variance(X) == Rational(35, 12)
+    assert E(X + Y) == 7
+    assert E(X + X) == 7
+    assert E(a*X + b) == a*E(X) + b
+    assert variance(X + Y) == variance(X) + variance(Y) == cmoment(X + Y, 2)
+    assert variance(X + X) == 4 * variance(X) == cmoment(X + X, 2)
+    assert cmoment(X, 0) == 1
+    assert cmoment(4*X, 3) == 64*cmoment(X, 3)
+    assert covariance(X, Y) is S.Zero
+    assert covariance(X, X + Y) == variance(X)
+    assert density(Eq(cos(X*S.Pi), 1))[True] == S.Half
+    assert correlation(X, Y) == 0
+    assert correlation(X, Y) == correlation(Y, X)
+    assert smoment(X + Y, 3) == skewness(X + Y)
+    assert smoment(X + Y, 4) == kurtosis(X + Y)
+    assert smoment(X, 0) == 1
+    assert P(X > 3) == S.Half
+    assert P(2*X > 6) == S.Half
+    assert P(X > Y) == Rational(5, 12)
+    assert P(Eq(X, Y)) == P(Eq(X, 1))
+
+    assert E(X, X > 3) == 5 == moment(X, 1, 0, X > 3)
+    assert E(X, Y > 3) == E(X) == moment(X, 1, 0, Y > 3)
+    assert E(X + Y, Eq(X, Y)) == E(2*X)
+    assert moment(X, 0) == 1
+    assert moment(5*X, 2) == 25*moment(X, 2)
+    assert quantile(X)(p) == Piecewise((nan, (p > 1) | (p < 0)),\
+        (S.One, p <= Rational(1, 6)), (S(2), p <= Rational(1, 3)), (S(3), p <= S.Half),\
+        (S(4), p <= Rational(2, 3)), (S(5), p <= Rational(5, 6)), (S(6), p <= 1))
+
+    assert P(X > 3, X > 3) is S.One
+    assert P(X > Y, Eq(Y, 6)) is S.Zero
+    assert P(Eq(X + Y, 12)) == Rational(1, 36)
+    assert P(Eq(X + Y, 12), Eq(X, 6)) == Rational(1, 6)
+
+    assert density(X + Y) == density(Y + Z) != density(X + X)
+    d = density(2*X + Y**Z)
+    assert d[S(22)] == Rational(1, 108) and d[S(4100)] == Rational(1, 216) and S(3130) not in d
+
+    assert pspace(X).domain.as_boolean() == Or(
+        *[Eq(X.symbol, i) for i in [1, 2, 3, 4, 5, 6]])
+
+    assert where(X > 3).set == FiniteSet(4, 5, 6)
+
+    assert characteristic_function(X)(t) == exp(6*I*t)/6 + exp(5*I*t)/6 + exp(4*I*t)/6 + exp(3*I*t)/6 + exp(2*I*t)/6 + exp(I*t)/6
+    assert moment_generating_function(X)(t) == exp(6*t)/6 + exp(5*t)/6 + exp(4*t)/6 + exp(3*t)/6 + exp(2*t)/6 + exp(t)/6
+    assert median(X) == FiniteSet(3, 4)
+    D = Die('D', 7)
+    assert median(D) == FiniteSet(4)
+    # Bayes test for die
+    BayesTest(X > 3, X + Y < 5)
+    BayesTest(Eq(X - Y, Z), Z > Y)
+    BayesTest(X > 3, X > 2)
+
+    # arg test for die
+    raises(ValueError, lambda: Die('X', -1))  # issue 8105: negative sides.
+    raises(ValueError, lambda: Die('X', 0))
+    raises(ValueError, lambda: Die('X', 1.5))  # issue 8103: non integer sides.
+
+    # symbolic test for die
+    n, k = symbols('n, k', positive=True)
+    D = Die('D', n)
+    dens = density(D).dict
+    assert dens == Density(DieDistribution(n))
+    assert set(dens.subs(n, 4).doit().keys()) == {1, 2, 3, 4}
+    assert set(dens.subs(n, 4).doit().values()) == {Rational(1, 4)}
+    k = Dummy('k', integer=True)
+    assert E(D).dummy_eq(
+        Sum(Piecewise((k/n, k <= n), (0, True)), (k, 1, n)))
+    assert variance(D).subs(n, 6).doit() == Rational(35, 12)
+
+    ki = Dummy('ki')
+    cumuf = cdf(D)(k)
+    assert cumuf.dummy_eq(
+    Sum(Piecewise((1/n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, k)))
+    assert cumuf.subs({n: 6, k: 2}).doit() == Rational(1, 3)
+
+    t = Dummy('t')
+    cf = characteristic_function(D)(t)
+    assert cf.dummy_eq(
+    Sum(Piecewise((exp(ki*I*t)/n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, n)))
+    assert cf.subs(n, 3).doit() == exp(3*I*t)/3 + exp(2*I*t)/3 + exp(I*t)/3
+    mgf = moment_generating_function(D)(t)
+    assert mgf.dummy_eq(
+    Sum(Piecewise((exp(ki*t)/n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, n)))
+    assert mgf.subs(n, 3).doit() == exp(3*t)/3 + exp(2*t)/3 + exp(t)/3
+
+def test_given():
+    X = Die('X', 6)
+    assert density(X, X > 5) == {S(6): S.One}
+    assert where(X > 2, X > 5).as_boolean() == Eq(X.symbol, 6)
+
+
+def test_domains():
+    X, Y = Die('x', 6), Die('y', 6)
+    x, y = X.symbol, Y.symbol
+    # Domains
+    d = where(X > Y)
+    assert d.condition == (x > y)
+    d = where(And(X > Y, Y > 3))
+    assert d.as_boolean() == Or(And(Eq(x, 5), Eq(y, 4)), And(Eq(x, 6),
+        Eq(y, 5)), And(Eq(x, 6), Eq(y, 4)))
+    assert len(d.elements) == 3
+
+    assert len(pspace(X + Y).domain.elements) == 36
+
+    Z = Die('x', 4)
+
+    raises(ValueError, lambda: P(X > Z))  # Two domains with same internal symbol
+
+    assert pspace(X + Y).domain.set == FiniteSet(1, 2, 3, 4, 5, 6)**2
+
+    assert where(X > 3).set == FiniteSet(4, 5, 6)
+    assert X.pspace.domain.dict == FiniteSet(
+        *[Dict({X.symbol: i}) for i in range(1, 7)])
+
+    assert where(X > Y).dict == FiniteSet(*[Dict({X.symbol: i, Y.symbol: j})
+            for i in range(1, 7) for j in range(1, 7) if i > j])
+
+def test_bernoulli():
+    p, a, b, t = symbols('p a b t')
+    X = Bernoulli('B', p, a, b)
+
+    assert E(X) == a*p + b*(-p + 1)
+    assert density(X)[a] == p
+    assert density(X)[b] == 1 - p
+    assert characteristic_function(X)(t) == p * exp(I * a * t) + (-p + 1) * exp(I * b * t)
+    assert moment_generating_function(X)(t) == p * exp(a * t) + (-p + 1) * exp(b * t)
+
+    X = Bernoulli('B', p, 1, 0)
+    z = Symbol("z")
+
+    assert E(X) == p
+    assert simplify(variance(X)) == p*(1 - p)
+    assert E(a*X + b) == a*E(X) + b
+    assert simplify(variance(a*X + b)) == simplify(a**2 * variance(X))
+    assert quantile(X)(z) == Piecewise((nan, (z > 1) | (z < 0)), (0, z <= 1 - p), (1, z <= 1))
+    Y = Bernoulli('Y', Rational(1, 2))
+    assert median(Y) == FiniteSet(0, 1)
+    Z = Bernoulli('Z', Rational(2, 3))
+    assert median(Z) == FiniteSet(1)
+    raises(ValueError, lambda: Bernoulli('B', 1.5))
+    raises(ValueError, lambda: Bernoulli('B', -0.5))
+
+    #issue 8248
+    assert X.pspace.compute_expectation(1) == 1
+
+    p = Rational(1, 5)
+    X = Binomial('X', 5, p)
+    Y = Binomial('Y', 7, 2*p)
+    Z = Binomial('Z', 9, 3*p)
+    assert coskewness(Y + Z, X + Y, X + Z).simplify() == 0
+    assert coskewness(Y + 2*X + Z, X + 2*Y + Z, X + 2*Z + Y).simplify() == \
+                        sqrt(1529)*Rational(12, 16819)
+    assert coskewness(Y + 2*X + Z, X + 2*Y + Z, X + 2*Z + Y, X < 2).simplify() \
+                        == -sqrt(357451121)*Rational(2812, 4646864573)
+
+def test_cdf():
+    D = Die('D', 6)
+    o = S.One
+
+    assert cdf(
+        D) == sympify({1: o/6, 2: o/3, 3: o/2, 4: 2*o/3, 5: 5*o/6, 6: o})
+
+
+def test_coins():
+    C, D = Coin('C'), Coin('D')
+    H, T = symbols('H, T')
+    assert P(Eq(C, D)) == S.Half
+    assert density(Tuple(C, D)) == {(H, H): Rational(1, 4), (H, T): Rational(1, 4),
+            (T, H): Rational(1, 4), (T, T): Rational(1, 4)}
+    assert dict(density(C).items()) == {H: S.Half, T: S.Half}
+
+    F = Coin('F', Rational(1, 10))
+    assert P(Eq(F, H)) == Rational(1, 10)
+
+    d = pspace(C).domain
+
+    assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T))
+
+    raises(ValueError, lambda: P(C > D))  # Can't intelligently compare H to T
+
+def test_binomial_verify_parameters():
+    raises(ValueError, lambda: Binomial('b', .2, .5))
+    raises(ValueError, lambda: Binomial('b', 3, 1.5))
+
+def test_binomial_numeric():
+    nvals = range(5)
+    pvals = [0, Rational(1, 4), S.Half, Rational(3, 4), 1]
+
+    for n in nvals:
+        for p in pvals:
+            X = Binomial('X', n, p)
+            assert E(X) == n*p
+            assert variance(X) == n*p*(1 - p)
+            if n > 0 and 0 < p < 1:
+                assert skewness(X) == (1 - 2*p)/sqrt(n*p*(1 - p))
+                assert kurtosis(X) == 3 + (1 - 6*p*(1 - p))/(n*p*(1 - p))
+            for k in range(n + 1):
+                assert P(Eq(X, k)) == binomial(n, k)*p**k*(1 - p)**(n - k)
+
+def test_binomial_quantile():
+    X = Binomial('X', 50, S.Half)
+    assert quantile(X)(0.95) == S(31)
+    assert median(X) == FiniteSet(25)
+
+    X = Binomial('X', 5, S.Half)
+    p = Symbol("p", positive=True)
+    assert quantile(X)(p) == Piecewise((nan, p > S.One), (S.Zero, p <= Rational(1, 32)),\
+        (S.One, p <= Rational(3, 16)), (S(2), p <= S.Half), (S(3), p <= Rational(13, 16)),\
+        (S(4), p <= Rational(31, 32)), (S(5), p <= S.One))
+    assert median(X) == FiniteSet(2, 3)
+
+
+def test_binomial_symbolic():
+    n = 2
+    p = symbols('p', positive=True)
+    X = Binomial('X', n, p)
+    t = Symbol('t')
+
+    assert simplify(E(X)) == n*p == simplify(moment(X, 1))
+    assert simplify(variance(X)) == n*p*(1 - p) == simplify(cmoment(X, 2))
+    assert cancel(skewness(X) - (1 - 2*p)/sqrt(n*p*(1 - p))) == 0
+    assert cancel((kurtosis(X)) - (3 + (1 - 6*p*(1 - p))/(n*p*(1 - p)))) == 0
+    assert characteristic_function(X)(t) == p ** 2 * exp(2 * I * t) + 2 * p * (-p + 1) * exp(I * t) + (-p + 1) ** 2
+    assert moment_generating_function(X)(t) == p ** 2 * exp(2 * t) + 2 * p * (-p + 1) * exp(t) + (-p + 1) ** 2
+
+    # Test ability to change success/failure winnings
+    H, T = symbols('H T')
+    Y = Binomial('Y', n, p, succ=H, fail=T)
+    assert simplify(E(Y) - (n*(H*p + T*(1 - p)))) == 0
+
+    # test symbolic dimensions
+    n = symbols('n')
+    B = Binomial('B', n, p)
+    raises(NotImplementedError, lambda: P(B > 2))
+    assert density(B).dict == Density(BinomialDistribution(n, p, 1, 0))
+    assert set(density(B).dict.subs(n, 4).doit().keys()) == \
+    {S.Zero, S.One, S(2), S(3), S(4)}
+    assert set(density(B).dict.subs(n, 4).doit().values()) == \
+    {(1 - p)**4, 4*p*(1 - p)**3, 6*p**2*(1 - p)**2, 4*p**3*(1 - p), p**4}
+    k = Dummy('k', integer=True)
+    assert E(B > 2).dummy_eq(
+        Sum(Piecewise((k*p**k*(1 - p)**(-k + n)*binomial(n, k), (k >= 0)
+        & (k <= n) & (k > 2)), (0, True)), (k, 0, n)))
+
+def test_beta_binomial():
+    # verify parameters
+    raises(ValueError, lambda: BetaBinomial('b', .2, 1, 2))
+    raises(ValueError, lambda: BetaBinomial('b', 2, -1, 2))
+    raises(ValueError, lambda: BetaBinomial('b', 2, 1, -2))
+    assert BetaBinomial('b', 2, 1, 1)
+
+    # test numeric values
+    nvals = range(1,5)
+    alphavals = [Rational(1, 4), S.Half, Rational(3, 4), 1, 10]
+    betavals = [Rational(1, 4), S.Half, Rational(3, 4), 1, 10]
+
+    for n in nvals:
+        for a in alphavals:
+            for b in betavals:
+                X = BetaBinomial('X', n, a, b)
+                assert E(X) == moment(X, 1)
+                assert variance(X) == cmoment(X, 2)
+
+    # test symbolic
+    n, a, b = symbols('a b n')
+    assert BetaBinomial('x', n, a, b)
+    n = 2 # Because we're using for loops, can't do symbolic n
+    a, b = symbols('a b', positive=True)
+    X = BetaBinomial('X', n, a, b)
+    t = Symbol('t')
+
+    assert E(X).expand() == moment(X, 1).expand()
+    assert variance(X).expand() == cmoment(X, 2).expand()
+    assert skewness(X) == smoment(X, 3)
+    assert characteristic_function(X)(t) == exp(2*I*t)*beta(a + 2, b)/beta(a, b) +\
+         2*exp(I*t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b)
+    assert moment_generating_function(X)(t) == exp(2*t)*beta(a + 2, b)/beta(a, b) +\
+         2*exp(t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b)
+
+def test_hypergeometric_numeric():
+    for N in range(1, 5):
+        for m in range(0, N + 1):
+            for n in range(1, N + 1):
+                X = Hypergeometric('X', N, m, n)
+                N, m, n = map(sympify, (N, m, n))
+                assert sum(density(X).values()) == 1
+                assert E(X) == n * m / N
+                if N > 1:
+                    assert variance(X) == n*(m/N)*(N - m)/N*(N - n)/(N - 1)
+                # Only test for skewness when defined
+                if N > 2 and 0 < m < N and n < N:
+                    assert skewness(X) == simplify((N - 2*m)*sqrt(N - 1)*(N - 2*n)
+                        / (sqrt(n*m*(N - m)*(N - n))*(N - 2)))
+
+def test_hypergeometric_symbolic():
+    N, m, n = symbols('N, m, n')
+    H = Hypergeometric('H', N, m, n)
+    dens = density(H).dict
+    expec = E(H > 2)
+    assert dens == Density(HypergeometricDistribution(N, m, n))
+    assert dens.subs(N, 5).doit() == Density(HypergeometricDistribution(5, m, n))
+    assert set(dens.subs({N: 3, m: 2, n: 1}).doit().keys()) == {S.Zero, S.One}
+    assert set(dens.subs({N: 3, m: 2, n: 1}).doit().values()) == {Rational(1, 3), Rational(2, 3)}
+    k = Dummy('k', integer=True)
+    assert expec.dummy_eq(
+        Sum(Piecewise((k*binomial(m, k)*binomial(N - m, -k + n)
+        /binomial(N, n), k > 2), (0, True)), (k, 0, n)))
+
+def test_rademacher():
+    X = Rademacher('X')
+    t = Symbol('t')
+
+    assert E(X) == 0
+    assert variance(X) == 1
+    assert density(X)[-1] == S.Half
+    assert density(X)[1] == S.Half
+    assert characteristic_function(X)(t) == exp(I*t)/2 + exp(-I*t)/2
+    assert moment_generating_function(X)(t) == exp(t) / 2 + exp(-t) / 2
+
+def test_ideal_soliton():
+    raises(ValueError, lambda : IdealSoliton('sol', -12))
+    raises(ValueError, lambda : IdealSoliton('sol', 13.2))
+    raises(ValueError, lambda : IdealSoliton('sol', 0))
+    f = Function('f')
+    raises(ValueError, lambda : density(IdealSoliton('sol', 10)).pmf(f))
+
+    k = Symbol('k', integer=True, positive=True)
+    x = Symbol('x', integer=True, positive=True)
+    t = Symbol('t')
+    sol = IdealSoliton('sol', k)
+    assert density(sol).low == S.One
+    assert density(sol).high == k
+    assert density(sol).dict == Density(density(sol))
+    assert density(sol).pmf(x) == Piecewise((1/k, Eq(x, 1)), (1/(x*(x - 1)), k >= x), (0, True))
+
+    k_vals = [5, 20, 50, 100, 1000]
+    for i in k_vals:
+        assert E(sol.subs(k, i)) == harmonic(i) == moment(sol.subs(k, i), 1)
+        assert variance(sol.subs(k, i)) == (i - 1) + harmonic(i) - harmonic(i)**2 == cmoment(sol.subs(k, i),2)
+        assert skewness(sol.subs(k, i)) == smoment(sol.subs(k, i), 3)
+        assert kurtosis(sol.subs(k, i)) == smoment(sol.subs(k, i), 4)
+
+    assert exp(I*t)/10 + Sum(exp(I*t*x)/(x*x - x), (x, 2, k)).subs(k, 10).doit() == characteristic_function(sol.subs(k, 10))(t)
+    assert exp(t)/10 + Sum(exp(t*x)/(x*x - x), (x, 2, k)).subs(k, 10).doit() == moment_generating_function(sol.subs(k, 10))(t)
+
+def test_robust_soliton():
+    raises(ValueError, lambda : RobustSoliton('robSol', -12, 0.1, 0.02))
+    raises(ValueError, lambda : RobustSoliton('robSol', 13, 1.89, 0.1))
+    raises(ValueError, lambda : RobustSoliton('robSol', 15, 0.6, -2.31))
+    f = Function('f')
+    raises(ValueError, lambda : density(RobustSoliton('robSol', 15, 0.6, 0.1)).pmf(f))
+
+    k = Symbol('k', integer=True, positive=True)
+    delta = Symbol('delta', positive=True)
+    c = Symbol('c', positive=True)
+    robSol = RobustSoliton('robSol', k, delta, c)
+    assert density(robSol).low == 1
+    assert density(robSol).high == k
+
+    k_vals = [10, 20, 50]
+    delta_vals = [0.2, 0.4, 0.6]
+    c_vals = [0.01, 0.03, 0.05]
+    for x in k_vals:
+        for y in delta_vals:
+            for z in c_vals:
+                assert E(robSol.subs({k: x, delta: y, c: z})) == moment(robSol.subs({k: x, delta: y, c: z}), 1)
+                assert variance(robSol.subs({k: x, delta: y, c: z})) == cmoment(robSol.subs({k: x, delta: y, c: z}), 2)
+                assert skewness(robSol.subs({k: x, delta: y, c: z})) == smoment(robSol.subs({k: x, delta: y, c: z}), 3)
+                assert kurtosis(robSol.subs({k: x, delta: y, c: z})) == smoment(robSol.subs({k: x, delta: y, c: z}), 4)
+
+def test_FiniteRV():
+    F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)}, check=True)
+    p = Symbol("p", positive=True)
+
+    assert dict(density(F).items()) == {S.One: S.Half, S(2): Rational(1, 4), S(3): Rational(1, 4)}
+    assert P(F >= 2) == S.Half
+    assert quantile(F)(p) == Piecewise((nan, p > S.One), (S.One, p <= S.Half),\
+        (S(2), p <= Rational(3, 4)),(S(3), True))
+
+    assert pspace(F).domain.as_boolean() == Or(
+        *[Eq(F.symbol, i) for i in [1, 2, 3]])
+
+    assert F.pspace.domain.set == FiniteSet(1, 2, 3)
+    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: S.Half, 3: S.Half}, check=True))
+    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: Rational(-1, 2), 3: S.One}, check=True))
+    raises(ValueError, lambda: FiniteRV('F', {1: S.One, 2: Rational(3, 2), 3: S.Zero,\
+        4: Rational(-1, 2), 5: Rational(-3, 4), 6: Rational(-1, 4)}, check=True))
+
+    # purposeful invalid pmf but it should not raise since check=False
+    # see test_drv_types.test_ContinuousRV for explanation
+    X = FiniteRV('X', {1: 1, 2: 2})
+    assert E(X) == 5
+    assert P(X <= 2) + P(X > 2) != 1
+
+def test_density_call():
+    from sympy.abc import p
+    x = Bernoulli('x', p)
+    d = density(x)
+    assert d(0) == 1 - p
+    assert d(S.Zero) == 1 - p
+    assert d(5) == 0
+
+    assert 0 in d
+    assert 5 not in d
+    assert d(S.Zero) == d[S.Zero]
+
+
+def test_DieDistribution():
+    from sympy.abc import x
+    X = DieDistribution(6)
+    assert X.pmf(S.Half) is S.Zero
+    assert X.pmf(x).subs({x: 1}).doit() == Rational(1, 6)
+    assert X.pmf(x).subs({x: 7}).doit() == 0
+    assert X.pmf(x).subs({x: -1}).doit() == 0
+    assert X.pmf(x).subs({x: Rational(1, 3)}).doit() == 0
+    raises(ValueError, lambda: X.pmf(Matrix([0, 0])))
+    raises(ValueError, lambda: X.pmf(x**2 - 1))
+
+def test_FinitePSpace():
+    X = Die('X', 6)
+    space = pspace(X)
+    assert space.density == DieDistribution(6)
+
+def test_symbolic_conditions():
+    B = Bernoulli('B', Rational(1, 4))
+    D = Die('D', 4)
+    b, n = symbols('b, n')
+    Y = P(Eq(B, b))
+    Z = E(D > n)
+    assert Y == \
+    Piecewise((Rational(1, 4), Eq(b, 1)), (0, True)) + \
+    Piecewise((Rational(3, 4), Eq(b, 0)), (0, True))
+    assert Z == \
+    Piecewise((Rational(1, 4), n < 1), (0, True)) + Piecewise((S.Half, n < 2), (0, True)) + \
+    Piecewise((Rational(3, 4), n < 3), (0, True)) + Piecewise((S.One, n < 4), (0, True))

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_joint_rv.py

@@ -0,0 +1,436 @@
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+from sympy.functions.elementary.complexes import polar_lift
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besselk
+from sympy.functions.special.gamma_functions import gamma
+from sympy.matrices.dense import eye
+from sympy.matrices.expressions.determinant import Determinant
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (Interval, ProductSet)
+from sympy.simplify.simplify import simplify
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.core.numbers import comp
+from sympy.integrals.integrals import integrate
+from sympy.matrices import Matrix, MatrixSymbol
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.stats import density, median, marginal_distribution, Normal, Laplace, E, sample
+from sympy.stats.joint_rv_types import (JointRV, MultivariateNormalDistribution,
+                JointDistributionHandmade, MultivariateT, NormalGamma,
+                GeneralizedMultivariateLogGammaOmega as GMVLGO, MultivariateBeta,
+                GeneralizedMultivariateLogGamma as GMVLG, MultivariateEwens,
+                Multinomial, NegativeMultinomial, MultivariateNormal,
+                MultivariateLaplace)
+from sympy.testing.pytest import raises, XFAIL, skip, slow
+from sympy.external import import_module
+
+from sympy.abc import x, y
+
+
+
+def test_Normal():
+    m = Normal('A', [1, 2], [[1, 0], [0, 1]])
+    A = MultivariateNormal('A', [1, 2], [[1, 0], [0, 1]])
+    assert m == A
+    assert density(m)(1, 2) == 1/(2*pi)
+    assert m.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
+    raises (ValueError, lambda:m[2])
+    n = Normal('B', [1, 2, 3], [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    p = Normal('C',  Matrix([1, 2]), Matrix([[1, 0], [0, 1]]))
+    assert density(m)(x, y) == density(p)(x, y)
+    assert marginal_distribution(n, 0, 1)(1, 2) == 1/(2*pi)
+    raises(ValueError, lambda: marginal_distribution(m))
+    assert integrate(density(m)(x, y), (x, -oo, oo), (y, -oo, oo)).evalf() == 1.0
+    N = Normal('N', [1, 2], [[x, 0], [0, y]])
+    assert density(N)(0, 0) == exp(-((4*x + y)/(2*x*y)))/(2*pi*sqrt(x*y))
+
+    raises (ValueError, lambda: Normal('M', [1, 2], [[1, 1], [1, -1]]))
+    # symbolic
+    n = symbols('n', integer=True, positive=True)
+    mu = MatrixSymbol('mu', n, 1)
+    sigma = MatrixSymbol('sigma', n, n)
+    X = Normal('X', mu, sigma)
+    assert density(X) == MultivariateNormalDistribution(mu, sigma)
+    raises (NotImplementedError, lambda: median(m))
+    # Below tests should work after issue #17267 is resolved
+    # assert E(X) == mu
+    # assert variance(X) == sigma
+
+    # test symbolic multivariate normal densities
+    n = 3
+
+    Sg = MatrixSymbol('Sg', n, n)
+    mu = MatrixSymbol('mu', n, 1)
+    obs = MatrixSymbol('obs', n, 1)
+
+    X = MultivariateNormal('X', mu, Sg)
+    density_X = density(X)
+
+    eval_a = density_X(obs).subs({Sg: eye(3),
+        mu: Matrix([0, 0, 0]), obs: Matrix([0, 0, 0])}).doit()
+    eval_b = density_X(0, 0, 0).subs({Sg: eye(3), mu: Matrix([0, 0, 0])}).doit()
+
+    assert eval_a == sqrt(2)/(4*pi**Rational(3/2))
+    assert eval_b == sqrt(2)/(4*pi**Rational(3/2))
+
+    n = symbols('n', integer=True, positive=True)
+
+    Sg = MatrixSymbol('Sg', n, n)
+    mu = MatrixSymbol('mu', n, 1)
+    obs = MatrixSymbol('obs', n, 1)
+
+    X = MultivariateNormal('X', mu, Sg)
+    density_X_at_obs = density(X)(obs)
+
+    expected_density = MatrixElement(
+        exp((S(1)/2) * (mu.T - obs.T) * Sg**(-1) * (-mu + obs)) / \
+        sqrt((2*pi)**n * Determinant(Sg)), 0, 0)
+
+    assert density_X_at_obs == expected_density
+
+
+def test_MultivariateTDist():
+    t1 = MultivariateT('T', [0, 0], [[1, 0], [0, 1]], 2)
+    assert(density(t1))(1, 1) == 1/(8*pi)
+    assert t1.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
+    assert integrate(density(t1)(x, y), (x, -oo, oo), \
+        (y, -oo, oo)).evalf() == 1.0
+    raises(ValueError, lambda: MultivariateT('T', [1, 2], [[1, 1], [1, -1]], 1))
+    t2 = MultivariateT('t2', [1, 2], [[x, 0], [0, y]], 1)
+    assert density(t2)(1, 2) == 1/(2*pi*sqrt(x*y))
+
+
+def test_multivariate_laplace():
+    raises(ValueError, lambda: Laplace('T', [1, 2], [[1, 2], [2, 1]]))
+    L = Laplace('L', [1, 0], [[1, 0], [0, 1]])
+    L2 = MultivariateLaplace('L2', [1, 0], [[1, 0], [0, 1]])
+    assert density(L)(2, 3) == exp(2)*besselk(0, sqrt(39))/pi
+    L1 = Laplace('L1', [1, 2], [[x, 0], [0, y]])
+    assert density(L1)(0, 1) == \
+        exp(2/y)*besselk(0, sqrt((2 + 4/y + 1/x)/y))/(pi*sqrt(x*y))
+    assert L.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
+    assert L.pspace.distribution == L2.pspace.distribution
+
+
+def test_NormalGamma():
+    ng = NormalGamma('G', 1, 2, 3, 4)
+    assert density(ng)(1, 1) == 32*exp(-4)/sqrt(pi)
+    assert ng.pspace.distribution.set == ProductSet(S.Reals, Interval(0, oo))
+    raises(ValueError, lambda:NormalGamma('G', 1, 2, 3, -1))
+    assert marginal_distribution(ng, 0)(1) == \
+        3*sqrt(10)*gamma(Rational(7, 4))/(10*sqrt(pi)*gamma(Rational(5, 4)))
+    assert marginal_distribution(ng, y)(1) == exp(Rational(-1, 4))/128
+    assert marginal_distribution(ng,[0,1])(x) == x**2*exp(-x/4)/128
+
+
+def test_GeneralizedMultivariateLogGammaDistribution():
+    h = S.Half
+    omega = Matrix([[1, h, h, h],
+                     [h, 1, h, h],
+                     [h, h, 1, h],
+                     [h, h, h, 1]])
+    v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4])
+    y_1, y_2, y_3, y_4 = symbols('y_1:5', real=True)
+    delta = symbols('d', positive=True)
+    G = GMVLGO('G', omega, v, l, mu)
+    Gd = GMVLG('Gd', delta, v, l, mu)
+    dend = ("d**4*Sum(4*24**(-n - 4)*(1 - d)**n*exp((n + 4)*(y_1 + 2*y_2 + 3*y_3 "
+            "+ 4*y_4) - exp(y_1) - exp(2*y_2)/2 - exp(3*y_3)/3 - exp(4*y_4)/4)/"
+            "(gamma(n + 1)*gamma(n + 4)**3), (n, 0, oo))")
+    assert str(density(Gd)(y_1, y_2, y_3, y_4)) == dend
+    den = ("5*2**(2/3)*5**(1/3)*Sum(4*24**(-n - 4)*(-2**(2/3)*5**(1/3)/4 + 1)**n*"
+          "exp((n + 4)*(y_1 + 2*y_2 + 3*y_3 + 4*y_4) - exp(y_1) - exp(2*y_2)/2 - "
+          "exp(3*y_3)/3 - exp(4*y_4)/4)/(gamma(n + 1)*gamma(n + 4)**3), (n, 0, oo))/64")
+    assert str(density(G)(y_1, y_2, y_3, y_4)) == den
+    marg = ("5*2**(2/3)*5**(1/3)*exp(4*y_1)*exp(-exp(y_1))*Integral(exp(-exp(4*G[3])"
+            "/4)*exp(16*G[3])*Integral(exp(-exp(3*G[2])/3)*exp(12*G[2])*Integral(exp("
+            "-exp(2*G[1])/2)*exp(8*G[1])*Sum((-1/4)**n*(-4 + 2**(2/3)*5**(1/3"
+            "))**n*exp(n*y_1)*exp(2*n*G[1])*exp(3*n*G[2])*exp(4*n*G[3])/(24**n*gamma(n + 1)"
+            "*gamma(n + 4)**3), (n, 0, oo)), (G[1], -oo, oo)), (G[2], -oo, oo)), (G[3]"
+            ", -oo, oo))/5308416")
+    assert str(marginal_distribution(G, G[0])(y_1)) == marg
+    omega_f1 = Matrix([[1, h, h]])
+    omega_f2 = Matrix([[1, h, h, h],
+                     [h, 1, 2, h],
+                     [h, h, 1, h],
+                     [h, h, h, 1]])
+    omega_f3 = Matrix([[6, h, h, h],
+                     [h, 1, 2, h],
+                     [h, h, 1, h],
+                     [h, h, h, 1]])
+    v_f = symbols("v_f", positive=False, real=True)
+    l_f = [1, 2, v_f, 4]
+    m_f = [v_f, 2, 3, 4]
+    omega_f4 = Matrix([[1, h, h, h, h],
+                     [h, 1, h, h, h],
+                     [h, h, 1, h, h],
+                     [h, h, h, 1, h],
+                     [h, h, h, h, 1]])
+    l_f1 = [1, 2, 3, 4, 5]
+    omega_f5 = Matrix([[1]])
+    mu_f5 = l_f5 = [1]
+
+    raises(ValueError, lambda: GMVLGO('G', omega_f1, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega_f2, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega_f3, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v_f, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v, l_f, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v, l, m_f))
+    raises(ValueError, lambda: GMVLGO('G', omega_f4, v, l, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega, v, l_f1, mu))
+    raises(ValueError, lambda: GMVLGO('G', omega_f5, v, l_f5, mu_f5))
+    raises(ValueError, lambda: GMVLG('G', Rational(3, 2), v, l, mu))
+
+
+def test_MultivariateBeta():
+    a1, a2 = symbols('a1, a2', positive=True)
+    a1_f, a2_f = symbols('a1, a2', positive=False, real=True)
+    mb = MultivariateBeta('B', [a1, a2])
+    mb_c = MultivariateBeta('C', a1, a2)
+    assert density(mb)(1, 2) == S(2)**(a2 - 1)*gamma(a1 + a2)/\
+                                (gamma(a1)*gamma(a2))
+    assert marginal_distribution(mb_c, 0)(3) == S(3)**(a1 - 1)*gamma(a1 + a2)/\
+                                                (a2*gamma(a1)*gamma(a2))
+    raises(ValueError, lambda: MultivariateBeta('b1', [a1_f, a2]))
+    raises(ValueError, lambda: MultivariateBeta('b2', [a1, a2_f]))
+    raises(ValueError, lambda: MultivariateBeta('b3', [0, 0]))
+    raises(ValueError, lambda: MultivariateBeta('b4', [a1_f, a2_f]))
+    assert mb.pspace.distribution.set == ProductSet(Interval(0, 1), Interval(0, 1))
+
+
+def test_MultivariateEwens():
+    n, theta, i = symbols('n theta i', positive=True)
+
+    # tests for integer dimensions
+    theta_f = symbols('t_f', negative=True)
+    a = symbols('a_1:4', positive = True, integer = True)
+    ed = MultivariateEwens('E', 3, theta)
+    assert density(ed)(a[0], a[1], a[2]) == Piecewise((6*2**(-a[1])*3**(-a[2])*
+                                            theta**a[0]*theta**a[1]*theta**a[2]/
+                                            (theta*(theta + 1)*(theta + 2)*
+                                            factorial(a[0])*factorial(a[1])*
+                                            factorial(a[2])), Eq(a[0] + 2*a[1] +
+                                            3*a[2], 3)), (0, True))
+    assert marginal_distribution(ed, ed[1])(a[1]) == Piecewise((6*2**(-a[1])*
+                                                    theta**a[1]/((theta + 1)*
+                                                    (theta + 2)*factorial(a[1])),
+                                                    Eq(2*a[1] + 1, 3)), (0, True))
+    raises(ValueError, lambda: MultivariateEwens('e1', 5, theta_f))
+    assert ed.pspace.distribution.set == ProductSet(Range(0, 4, 1),
+                                            Range(0, 2, 1), Range(0, 2, 1))
+
+    # tests for symbolic dimensions
+    eds = MultivariateEwens('E', n, theta)
+    a = IndexedBase('a')
+    j, k = symbols('j, k')
+    den = Piecewise((factorial(n)*Product(theta**a[j]*(j + 1)**(-a[j])/
+           factorial(a[j]), (j, 0, n - 1))/RisingFactorial(theta, n),
+            Eq(n, Sum((k + 1)*a[k], (k, 0, n - 1)))), (0, True))
+    assert density(eds)(a).dummy_eq(den)
+
+
+def test_Multinomial():
+    n, x1, x2, x3, x4 = symbols('n, x1, x2, x3, x4', nonnegative=True, integer=True)
+    p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True)
+    p1_f, n_f = symbols('p1_f, n_f', negative=True)
+    M = Multinomial('M', n, [p1, p2, p3, p4])
+    C = Multinomial('C', 3, p1, p2, p3)
+    f = factorial
+    assert density(M)(x1, x2, x3, x4) == Piecewise((p1**x1*p2**x2*p3**x3*p4**x4*
+                                            f(n)/(f(x1)*f(x2)*f(x3)*f(x4)),
+                                            Eq(n, x1 + x2 + x3 + x4)), (0, True))
+    assert marginal_distribution(C, C[0])(x1).subs(x1, 1) ==\
+                                                            3*p1*p2**2 +\
+                                                            6*p1*p2*p3 +\
+                                                            3*p1*p3**2
+    raises(ValueError, lambda: Multinomial('b1', 5, [p1, p2, p3, p1_f]))
+    raises(ValueError, lambda: Multinomial('b2', n_f, [p1, p2, p3, p4]))
+    raises(ValueError, lambda: Multinomial('b3', n, 0.5, 0.4, 0.3, 0.1))
+
+
+def test_NegativeMultinomial():
+    k0, x1, x2, x3, x4 = symbols('k0, x1, x2, x3, x4', nonnegative=True, integer=True)
+    p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True)
+    p1_f = symbols('p1_f', negative=True)
+    N = NegativeMultinomial('N', 4, [p1, p2, p3, p4])
+    C = NegativeMultinomial('C', 4, 0.1, 0.2, 0.3)
+    g = gamma
+    f = factorial
+    assert simplify(density(N)(x1, x2, x3, x4) -
+            p1**x1*p2**x2*p3**x3*p4**x4*(-p1 - p2 - p3 - p4 + 1)**4*g(x1 + x2 +
+            x3 + x4 + 4)/(6*f(x1)*f(x2)*f(x3)*f(x4))) is S.Zero
+    assert comp(marginal_distribution(C, C[0])(1).evalf(), 0.33, .01)
+    raises(ValueError, lambda: NegativeMultinomial('b1', 5, [p1, p2, p3, p1_f]))
+    raises(ValueError, lambda: NegativeMultinomial('b2', k0, 0.5, 0.4, 0.3, 0.4))
+    assert N.pspace.distribution.set == ProductSet(Range(0, oo, 1),
+                    Range(0, oo, 1), Range(0, oo, 1), Range(0, oo, 1))
+
+
+@slow
+def test_JointPSpace_marginal_distribution():
+    T = MultivariateT('T', [0, 0], [[1, 0], [0, 1]], 2)
+    got = marginal_distribution(T, T[1])(x)
+    ans = sqrt(2)*(x**2/2 + 1)/(4*polar_lift(x**2/2 + 1)**(S(5)/2))
+    assert got == ans, got
+    assert integrate(marginal_distribution(T, 1)(x), (x, -oo, oo)) == 1
+
+    t = MultivariateT('T', [0, 0, 0], [[1, 0, 0], [0, 1, 0], [0, 0, 1]], 3)
+    assert comp(marginal_distribution(t, 0)(1).evalf(), 0.2, .01)
+
+
+def test_JointRV():
+    x1, x2 = (Indexed('x', i) for i in (1, 2))
+    pdf = exp(-x1**2/2 + x1 - x2**2/2 - S.Half)/(2*pi)
+    X = JointRV('x', pdf)
+    assert density(X)(1, 2) == exp(-2)/(2*pi)
+    assert isinstance(X.pspace.distribution, JointDistributionHandmade)
+    assert marginal_distribution(X, 0)(2) == sqrt(2)*exp(Rational(-1, 2))/(2*sqrt(pi))
+
+
+def test_expectation():
+    m = Normal('A', [x, y], [[1, 0], [0, 1]])
+    assert simplify(E(m[1])) == y
+
+
+@XFAIL
+def test_joint_vector_expectation():
+    m = Normal('A', [x, y], [[1, 0], [0, 1]])
+    assert E(m) == (x, y)
+
+
+def test_sample_numpy():
+    distribs_numpy = [
+        MultivariateNormal("M", [3, 4], [[2, 1], [1, 2]]),
+        MultivariateBeta("B", [0.4, 5, 15, 50, 203]),
+        Multinomial("N", 50, [0.3, 0.2, 0.1, 0.25, 0.15])
+    ]
+    size = 3
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests for _sample_numpy.')
+    else:
+        for X in distribs_numpy:
+            samps = sample(X, size=size, library='numpy')
+            for sam in samps:
+                assert tuple(sam) in X.pspace.distribution.set
+        N_c = NegativeMultinomial('N', 3, 0.1, 0.1, 0.1)
+        raises(NotImplementedError, lambda: sample(N_c, library='numpy'))
+
+
+def test_sample_scipy():
+    distribs_scipy = [
+        MultivariateNormal("M", [0, 0], [[0.1, 0.025], [0.025, 0.1]]),
+        MultivariateBeta("B", [0.4, 5, 15]),
+        Multinomial("N", 8, [0.3, 0.2, 0.1, 0.4])
+    ]
+
+    size = 3
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size)
+            samps2 = sample(X, size=(2, 2))
+            for sam in samps:
+                assert tuple(sam) in X.pspace.distribution.set
+            for i in range(2):
+                for j in range(2):
+                    assert tuple(samps2[i][j]) in X.pspace.distribution.set
+        N_c = NegativeMultinomial('N', 3, 0.1, 0.1, 0.1)
+        raises(NotImplementedError, lambda: sample(N_c))
+
+
+def test_sample_pymc():
+    distribs_pymc = [
+        MultivariateNormal("M", [5, 2], [[1, 0], [0, 1]]),
+        MultivariateBeta("B", [0.4, 5, 15]),
+        Multinomial("N", 4, [0.3, 0.2, 0.1, 0.4])
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert tuple(sam.flatten()) in X.pspace.distribution.set
+        N_c = NegativeMultinomial('N', 3, 0.1, 0.1, 0.1)
+        raises(NotImplementedError, lambda: sample(N_c, library='pymc'))
+
+
+def test_sample_seed():
+    x1, x2 = (Indexed('x', i) for i in (1, 2))
+    pdf = exp(-x1**2/2 + x1 - x2**2/2 - S.Half)/(2*pi)
+    X = JointRV('x', pdf)
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(X, size=10, library=lib, seed=0)
+                s1 = sample(X, size=10, library=lib, seed=0)
+                s2 = sample(X, size=10, library=lib, seed=1)
+                assert all(s0 == s1)
+                assert all(s1 != s2)
+        except NotImplementedError:
+            continue
+
+#
+# XXX: This fails for pymc. Previously the test appeared to pass but that is
+# just because the library argument was not passed so the test always used
+# scipy.
+#
+def test_issue_21057():
+    m = Normal("x", [0, 0], [[0, 0], [0, 0]])
+    n = MultivariateNormal("x", [0, 0], [[0, 0], [0, 0]])
+    p = Normal("x", [0, 0], [[0, 0], [0, 1]])
+    assert m == n
+    libraries = ('scipy', 'numpy')  # , 'pymc')  # <-- pymc fails
+    for library in libraries:
+        try:
+            imported_lib = import_module(library)
+            if imported_lib:
+                s1 = sample(m, size=8, library=library)
+                s2 = sample(n, size=8, library=library)
+                s3 = sample(p, size=8, library=library)
+                assert tuple(s1.flatten()) == tuple(s2.flatten())
+                for s in s3:
+                    assert tuple(s.flatten()) in p.pspace.distribution.set
+        except NotImplementedError:
+            continue
+
+
+#
+# When this passes the pymc part can be uncommented in test_issue_21057 above
+# and this can be deleted.
+#
+@XFAIL
+def test_issue_21057_pymc():
+    m = Normal("x", [0, 0], [[0, 0], [0, 0]])
+    n = MultivariateNormal("x", [0, 0], [[0, 0], [0, 0]])
+    p = Normal("x", [0, 0], [[0, 0], [0, 1]])
+    assert m == n
+    libraries = ('pymc',)
+    for library in libraries:
+        try:
+            imported_lib = import_module(library)
+            if imported_lib:
+                s1 = sample(m, size=8, library=library)
+                s2 = sample(n, size=8, library=library)
+                s3 = sample(p, size=8, library=library)
+                assert tuple(s1.flatten()) == tuple(s2.flatten())
+                for s in s3:
+                    assert tuple(s.flatten()) in p.pspace.distribution.set
+        except NotImplementedError:
+            continue

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_matrix_distributions.py

@@ -0,0 +1,186 @@
+from sympy.concrete.products import Product
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.gamma_functions import gamma
+from sympy.matrices import Determinant, Matrix, Trace, MatrixSymbol, MatrixSet
+from sympy.stats import density, sample
+from sympy.stats.matrix_distributions import (MatrixGammaDistribution,
+                MatrixGamma, MatrixPSpace, Wishart, MatrixNormal, MatrixStudentT)
+from sympy.testing.pytest import raises, skip
+from sympy.external import import_module
+
+
+def test_MatrixPSpace():
+    M = MatrixGammaDistribution(1, 2, [[2, 1], [1, 2]])
+    MP = MatrixPSpace('M', M, 2, 2)
+    assert MP.distribution == M
+    raises(ValueError, lambda: MatrixPSpace('M', M, 1.2, 2))
+
+def test_MatrixGamma():
+    M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
+    assert M.pspace.distribution.set == MatrixSet(2, 2, S.Reals)
+    assert isinstance(density(M), MatrixGammaDistribution)
+    X = MatrixSymbol('X', 2, 2)
+    num = exp(Trace(Matrix([[-S(1)/2, 0], [0, -S(1)/2]])*X))
+    assert density(M)(X).doit() == num/(4*pi*sqrt(Determinant(X)))
+    assert density(M)([[2, 1], [1, 2]]).doit() == sqrt(3)*exp(-2)/(12*pi)
+    X = MatrixSymbol('X', 1, 2)
+    Y = MatrixSymbol('Y', 1, 2)
+    assert density(M)([X, Y]).doit() == exp(-X[0, 0]/2 - Y[0, 1]/2)/(4*pi*sqrt(
+                                X[0, 0]*Y[0, 1] - X[0, 1]*Y[0, 0]))
+    # symbolic
+    a, b = symbols('a b', positive=True)
+    d = symbols('d', positive=True, integer=True)
+    Y = MatrixSymbol('Y', d, d)
+    Z = MatrixSymbol('Z', 2, 2)
+    SM = MatrixSymbol('SM', d, d)
+    M2 = MatrixGamma('M2', a, b, SM)
+    M3 = MatrixGamma('M3', 2, 3, [[2, 1], [1, 2]])
+    k = Dummy('k')
+    exprd = pi**(-d*(d - 1)/4)*b**(-a*d)*exp(Trace((-1/b)*SM**(-1)*Y)
+        )*Determinant(SM)**(-a)*Determinant(Y)**(a - d/2 - S(1)/2)/Product(
+        gamma(-k/2 + a + S(1)/2), (k, 1, d))
+    assert density(M2)(Y).dummy_eq(exprd)
+    raises(NotImplementedError, lambda: density(M3 + M)(Z))
+    raises(ValueError, lambda: density(M)(1))
+    raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixGamma('M', -1, -2, [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [0]]))
+
+def test_Wishart():
+    W = Wishart('W', 5, [[1, 0], [0, 1]])
+    assert W.pspace.distribution.set == MatrixSet(2, 2, S.Reals)
+    X = MatrixSymbol('X', 2, 2)
+    term1 = exp(Trace(Matrix([[-S(1)/2, 0], [0, -S(1)/2]])*X))
+    assert density(W)(X).doit() == term1 * Determinant(X)/(24*pi)
+    assert density(W)([[2, 1], [1, 2]]).doit() == exp(-2)/(8*pi)
+    n = symbols('n', positive=True)
+    d = symbols('d', positive=True, integer=True)
+    Y = MatrixSymbol('Y', d, d)
+    SM = MatrixSymbol('SM', d, d)
+    W = Wishart('W', n, SM)
+    k = Dummy('k')
+    exprd = 2**(-d*n/2)*pi**(-d*(d - 1)/4)*exp(Trace(-(S(1)/2)*SM**(-1)*Y)
+    )*Determinant(SM)**(-n/2)*Determinant(Y)**(
+    -d/2 + n/2 - S(1)/2)/Product(gamma(-k/2 + n/2 + S(1)/2), (k, 1, d))
+    assert density(W)(Y).dummy_eq(exprd)
+    raises(ValueError, lambda: density(W)(1))
+    raises(ValueError, lambda: Wishart('W', -1, [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: Wishart('W', -1, [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: Wishart('W',  2, [[1, 0], [0]]))
+
+def test_MatrixNormal():
+    M = MatrixNormal('M', [[5, 6]], [4], [[2, 1], [1, 2]])
+    assert M.pspace.distribution.set == MatrixSet(1, 2, S.Reals)
+    X = MatrixSymbol('X', 1, 2)
+    term1 = exp(-Trace(Matrix([[ S(2)/3, -S(1)/3], [-S(1)/3, S(2)/3]])*(
+            Matrix([[-5], [-6]]) + X.T)*Matrix([[S(1)/4]])*(Matrix([[-5, -6]]) + X))/2)
+    assert density(M)(X).doit() == (sqrt(3)) * term1/(24*pi)
+    assert density(M)([[7, 8]]).doit() == sqrt(3)*exp(-S(1)/3)/(24*pi)
+    d, n = symbols('d n', positive=True, integer=True)
+    SM2 = MatrixSymbol('SM2', d, d)
+    SM1 = MatrixSymbol('SM1', n, n)
+    LM = MatrixSymbol('LM', n, d)
+    Y = MatrixSymbol('Y', n, d)
+    M = MatrixNormal('M', LM, SM1, SM2)
+    exprd = (2*pi)**(-d*n/2)*exp(-Trace(SM2**(-1)*(-LM.T + Y.T)*SM1**(-1)*(-LM + Y)
+        )/2)*Determinant(SM1)**(-d/2)*Determinant(SM2)**(-n/2)
+    assert density(M)(Y).doit() == exprd
+    raises(ValueError, lambda: density(M)(1))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [0, 1]], [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [2, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [0, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [2]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixNormal('M', [1, 2], [[1, 0], [2, 1]], [[1, 0], [0]]))
+    raises(ValueError, lambda: MatrixNormal('M', [[1, 2]], [[1, 0], [0, 1]], [[1, 0]]))
+    raises(ValueError, lambda: MatrixNormal('M', [[1, 2]], [1], [[1, 0]]))
+
+def test_MatrixStudentT():
+    M = MatrixStudentT('M', 2, [[5, 6]], [[2, 1], [1, 2]], [4])
+    assert M.pspace.distribution.set == MatrixSet(1, 2, S.Reals)
+    X = MatrixSymbol('X', 1, 2)
+    D = pi ** (-1.0) * Determinant(Matrix([[4]])) ** (-1.0) * Determinant(Matrix([[2, 1], [1, 2]])) \
+        ** (-0.5) / Determinant(Matrix([[S(1) / 4]]) * (Matrix([[-5, -6]]) + X)
+                                * Matrix([[S(2) / 3, -S(1) / 3], [-S(1) / 3, S(2) / 3]]) * (
+                                        Matrix([[-5], [-6]]) + X.T) + Matrix([[1]])) ** 2
+    assert density(M)(X) == D
+
+    v = symbols('v', positive=True)
+    n, p = 1, 2
+    Omega = MatrixSymbol('Omega', p, p)
+    Sigma = MatrixSymbol('Sigma', n, n)
+    Location = MatrixSymbol('Location', n, p)
+    Y = MatrixSymbol('Y', n, p)
+    M = MatrixStudentT('M', v, Location, Omega, Sigma)
+
+    exprd = gamma(v/2 + 1)*Determinant(Matrix([[1]]) + Sigma**(-1)*(-Location + Y)*Omega**(-1)*(-Location.T + Y.T))**(-v/2 - 1) / \
+            (pi*gamma(v/2)*sqrt(Determinant(Omega))*Determinant(Sigma))
+
+    assert density(M)(Y) == exprd
+    raises(ValueError, lambda: density(M)(1))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [0, 1]], [[1, 0], [2, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [2, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [0, 1]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [2]], [[1, 0], [0, 1]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [1, 2], [[1, 0], [2, 1]], [[1], [2]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [[1, 2]], [[1, 0], [0, 1]], [[1, 0]]))
+    raises(ValueError, lambda: MatrixStudentT('M', 1, [[1, 2]], [1], [[1, 0]]))
+    raises(ValueError, lambda: MatrixStudentT('M', -1, [1, 2], [[1, 0], [0, 1]], [4]))
+
+def test_sample_scipy():
+    distribs_scipy = [
+        MatrixNormal('M', [[5, 6]], [4], [[2, 1], [1, 2]]),
+        Wishart('W', 5, [[1, 0], [0, 1]])
+    ]
+
+    size = 5
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy not installed. Abort tests for _sample_scipy.')
+    else:
+        for X in distribs_scipy:
+            samps = sample(X, size=size)
+            for sam in samps:
+                assert Matrix(sam) in X.pspace.distribution.set
+        M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
+        raises(NotImplementedError, lambda: sample(M, size=3))
+
+def test_sample_pymc():
+    distribs_pymc = [
+        MatrixNormal('M', [[5, 6], [3, 4]], [[1, 0], [0, 1]], [[2, 1], [1, 2]]),
+        Wishart('W', 7, [[2, 1], [1, 2]])
+    ]
+    size = 3
+    pymc = import_module('pymc')
+    if not pymc:
+        skip('PyMC is not installed. Abort tests for _sample_pymc.')
+    else:
+        for X in distribs_pymc:
+            samps = sample(X, size=size, library='pymc')
+            for sam in samps:
+                assert Matrix(sam) in X.pspace.distribution.set
+        M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
+        raises(NotImplementedError, lambda: sample(M, size=3))
+
+def test_sample_seed():
+    X = MatrixNormal('M', [[5, 6], [3, 4]], [[1, 0], [0, 1]], [[2, 1], [1, 2]])
+
+    libraries = ['scipy', 'numpy', 'pymc']
+    for lib in libraries:
+        try:
+            imported_lib = import_module(lib)
+            if imported_lib:
+                s0, s1, s2 = [], [], []
+                s0 = sample(X, size=10, library=lib, seed=0)
+                s1 = sample(X, size=10, library=lib, seed=0)
+                s2 = sample(X, size=10, library=lib, seed=1)
+                for i in range(10):
+                    assert (s0[i] == s1[i]).all()
+                    assert (s1[i] != s2[i]).all()
+
+        except NotImplementedError:
+            continue

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_mix.py

@@ -0,0 +1,82 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Integer, oo, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.simplify.simplify import simplify
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.functions.elementary.piecewise import ExprCondPair
+from sympy.stats import (Poisson, Beta, Exponential, P,
+                        Multinomial, MultivariateBeta)
+from sympy.stats.crv_types import Normal
+from sympy.stats.drv_types import PoissonDistribution
+from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
+from sympy.stats.joint_rv import MarginalDistribution
+from sympy.stats.rv import pspace, density
+from sympy.testing.pytest import ignore_warnings
+
+def test_density():
+    x = Symbol('x')
+    l = Symbol('l', positive=True)
+    rate = Beta(l, 2, 3)
+    X = Poisson(x, rate)
+    assert isinstance(pspace(X), CompoundPSpace)
+    assert density(X, Eq(rate, rate.symbol)) == PoissonDistribution(l)
+    N1 = Normal('N1', 0, 1)
+    N2 = Normal('N2', N1, 2)
+    assert density(N2)(0).doit() == sqrt(10)/(10*sqrt(pi))
+    assert simplify(density(N2, Eq(N1, 1))(x)) == \
+        sqrt(2)*exp(-(x - 1)**2/8)/(4*sqrt(pi))
+    assert simplify(density(N2)(x)) == sqrt(10)*exp(-x**2/10)/(10*sqrt(pi))
+
+def test_MarginalDistribution():
+    a1, p1, p2 = symbols('a1 p1 p2', positive=True)
+    C = Multinomial('C', 2, p1, p2)
+    B = MultivariateBeta('B', a1, C[0])
+    MGR = MarginalDistribution(B, (C[0],))
+    mgrc = Mul(Symbol('B'), Piecewise(ExprCondPair(Mul(Integer(2),
+    Pow(Symbol('p1', positive=True), Indexed(IndexedBase(Symbol('C')),
+    Integer(0))), Pow(Symbol('p2', positive=True),
+    Indexed(IndexedBase(Symbol('C')), Integer(1))),
+    Pow(factorial(Indexed(IndexedBase(Symbol('C')), Integer(0))), Integer(-1)),
+    Pow(factorial(Indexed(IndexedBase(Symbol('C')), Integer(1))), Integer(-1))),
+    Eq(Add(Indexed(IndexedBase(Symbol('C')), Integer(0)),
+    Indexed(IndexedBase(Symbol('C')), Integer(1))), Integer(2))),
+    ExprCondPair(Integer(0), True)), Pow(gamma(Symbol('a1', positive=True)),
+    Integer(-1)), gamma(Add(Symbol('a1', positive=True),
+    Indexed(IndexedBase(Symbol('C')), Integer(0)))),
+    Pow(gamma(Indexed(IndexedBase(Symbol('C')), Integer(0))), Integer(-1)),
+    Pow(Indexed(IndexedBase(Symbol('B')), Integer(0)),
+    Add(Symbol('a1', positive=True), Integer(-1))),
+    Pow(Indexed(IndexedBase(Symbol('B')), Integer(1)),
+    Add(Indexed(IndexedBase(Symbol('C')), Integer(0)), Integer(-1))))
+    assert MGR(C) == mgrc
+
+def test_compound_distribution():
+    Y = Poisson('Y', 1)
+    Z = Poisson('Z', Y)
+    assert isinstance(pspace(Z), CompoundPSpace)
+    assert isinstance(pspace(Z).distribution, CompoundDistribution)
+    assert Z.pspace.distribution.pdf(1).doit() == exp(-2)*exp(exp(-1))
+
+def test_mix_expression():
+    Y, E = Poisson('Y', 1), Exponential('E', 1)
+    k = Dummy('k')
+    expr1 = Integral(Sum(exp(-1)*Integral(exp(-k)*DiracDelta(k - 2), (k, 0, oo)
+    )/factorial(k), (k, 0, oo)), (k, -oo, 0))
+    expr2 = Integral(Sum(exp(-1)*Integral(exp(-k)*DiracDelta(k - 2), (k, 0, oo)
+    )/factorial(k), (k, 0, oo)), (k, 0, oo))
+    assert P(Eq(Y + E, 1)) == 0
+    assert P(Ne(Y + E, 2)) == 1
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert P(E + Y < 2, evaluate=False).rewrite(Integral).dummy_eq(expr1)
+        assert P(E + Y > 2, evaluate=False).rewrite(Integral).dummy_eq(expr2)

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_random_matrix.py

@@ -0,0 +1,135 @@
+from sympy.concrete.products import Product
+from sympy.core.function import Lambda
+from sympy.core.numbers import (I, Rational, 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.elementary.miscellaneous import sqrt
+from sympy.integrals.integrals import Integral
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.trace import Trace
+from sympy.tensor.indexed import IndexedBase
+from sympy.stats import (GaussianUnitaryEnsemble as GUE, density,
+                         GaussianOrthogonalEnsemble as GOE,
+                         GaussianSymplecticEnsemble as GSE,
+                         joint_eigen_distribution,
+                         CircularUnitaryEnsemble as CUE,
+                         CircularOrthogonalEnsemble as COE,
+                         CircularSymplecticEnsemble as CSE,
+                         JointEigenDistribution,
+                         level_spacing_distribution,
+                         Normal, Beta)
+from sympy.stats.joint_rv_types import JointDistributionHandmade
+from sympy.stats.rv import RandomMatrixSymbol
+from sympy.stats.random_matrix_models import GaussianEnsemble, RandomMatrixPSpace
+from sympy.testing.pytest import raises
+
+def test_GaussianEnsemble():
+    G = GaussianEnsemble('G', 3)
+    assert density(G) == G.pspace.model
+    raises(ValueError, lambda: GaussianEnsemble('G', 3.5))
+
+def test_GaussianUnitaryEnsemble():
+    H = RandomMatrixSymbol('H', 3, 3)
+    G = GUE('U', 3)
+    assert density(G)(H) == sqrt(2)*exp(-3*Trace(H**2)/2)/(4*pi**Rational(9, 2))
+    i, j = (Dummy('i', integer=True, positive=True),
+            Dummy('j', integer=True, positive=True))
+    l = IndexedBase('l')
+    assert joint_eigen_distribution(G).dummy_eq(
+            Lambda((l[1], l[2], l[3]),
+            27*sqrt(6)*exp(-3*(l[1]**2)/2 - 3*(l[2]**2)/2 - 3*(l[3]**2)/2)*
+            Product(Abs(l[i] - l[j])**2, (j, i + 1, 3), (i, 1, 2))/(16*pi**Rational(3, 2))))
+    s = Dummy('s')
+    assert level_spacing_distribution(G).dummy_eq(Lambda(s, 32*s**2*exp(-4*s**2/pi)/pi**2))
+
+
+def test_GaussianOrthogonalEnsemble():
+    H = RandomMatrixSymbol('H', 3, 3)
+    _H = MatrixSymbol('_H', 3, 3)
+    G = GOE('O', 3)
+    assert density(G)(H) == exp(-3*Trace(H**2)/4)/Integral(exp(-3*Trace(_H**2)/4), _H)
+    i, j = (Dummy('i', integer=True, positive=True),
+            Dummy('j', integer=True, positive=True))
+    l = IndexedBase('l')
+    assert joint_eigen_distribution(G).dummy_eq(
+            Lambda((l[1], l[2], l[3]),
+            9*sqrt(2)*exp(-3*l[1]**2/2 - 3*l[2]**2/2 - 3*l[3]**2/2)*
+            Product(Abs(l[i] - l[j]), (j, i + 1, 3), (i, 1, 2))/(32*pi)))
+    s = Dummy('s')
+    assert level_spacing_distribution(G).dummy_eq(Lambda(s, s*pi*exp(-s**2*pi/4)/2))
+
+def test_GaussianSymplecticEnsemble():
+    H = RandomMatrixSymbol('H', 3, 3)
+    _H = MatrixSymbol('_H', 3, 3)
+    G = GSE('O', 3)
+    assert density(G)(H) == exp(-3*Trace(H**2))/Integral(exp(-3*Trace(_H**2)), _H)
+    i, j = (Dummy('i', integer=True, positive=True),
+            Dummy('j', integer=True, positive=True))
+    l = IndexedBase('l')
+    assert joint_eigen_distribution(G).dummy_eq(
+            Lambda((l[1], l[2], l[3]),
+            162*sqrt(3)*exp(-3*l[1]**2/2 - 3*l[2]**2/2 - 3*l[3]**2/2)*
+            Product(Abs(l[i] - l[j])**4, (j, i + 1, 3), (i, 1, 2))/(5*pi**Rational(3, 2))))
+    s = Dummy('s')
+    assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)*s**4*exp(-64*s**2/(9*pi))/(729*pi**3)))
+
+def test_CircularUnitaryEnsemble():
+    CU = CUE('U', 3)
+    j, k = (Dummy('j', integer=True, positive=True),
+            Dummy('k', integer=True, positive=True))
+    t = IndexedBase('t')
+    assert joint_eigen_distribution(CU).dummy_eq(
+            Lambda((t[1], t[2], t[3]),
+            Product(Abs(exp(I*t[j]) - exp(I*t[k]))**2,
+            (j, k + 1, 3), (k, 1, 2))/(48*pi**3))
+    )
+
+def test_CircularOrthogonalEnsemble():
+    CO = COE('U', 3)
+    j, k = (Dummy('j', integer=True, positive=True),
+            Dummy('k', integer=True, positive=True))
+    t = IndexedBase('t')
+    assert joint_eigen_distribution(CO).dummy_eq(
+            Lambda((t[1], t[2], t[3]),
+            Product(Abs(exp(I*t[j]) - exp(I*t[k])),
+            (j, k + 1, 3), (k, 1, 2))/(48*pi**2))
+    )
+
+def test_CircularSymplecticEnsemble():
+    CS = CSE('U', 3)
+    j, k = (Dummy('j', integer=True, positive=True),
+            Dummy('k', integer=True, positive=True))
+    t = IndexedBase('t')
+    assert joint_eigen_distribution(CS).dummy_eq(
+            Lambda((t[1], t[2], t[3]),
+            Product(Abs(exp(I*t[j]) - exp(I*t[k]))**4,
+            (j, k + 1, 3), (k, 1, 2))/(720*pi**3))
+    )
+
+def test_JointEigenDistribution():
+    A = Matrix([[Normal('A00', 0, 1), Normal('A01', 1, 1)],
+                [Beta('A10', 1, 1), Beta('A11', 1, 1)]])
+    assert JointEigenDistribution(A) == \
+    JointDistributionHandmade(-sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)/2 +
+    A[0, 0]/2 + A[1, 1]/2, sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)/2 + A[0, 0]/2 + A[1, 1]/2)
+    raises(ValueError, lambda: JointEigenDistribution(Matrix([[1, 0], [2, 1]])))
+
+def test_issue_19841():
+    G1 = GUE('U', 2)
+    G2 = G1.xreplace({2: 2})
+    assert G1.args == G2.args
+
+    X = MatrixSymbol('X', 2, 2)
+    G = GSE('U', 2)
+    h_pspace = RandomMatrixPSpace('P', model=density(G))
+    H = RandomMatrixSymbol('H', 2, 2, pspace=h_pspace)
+    H2 = RandomMatrixSymbol('H', 2, 2, pspace=None)
+    assert H.doit() == H
+
+    assert (2*H).xreplace({H: X}) == 2*X
+    assert (2*H).xreplace({H2: X}) == 2*H
+    assert (2*H2).xreplace({H: X}) == 2*H2
+    assert (2*H2).xreplace({H2: X}) == 2*X

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_rv.py

@@ -0,0 +1,441 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.function import Lambda
+from sympy.core.numbers import (Rational, nan, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (FallingFactorial, binomial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.integrals.integrals import integrate
+from sympy.logic.boolalg import (And, Or)
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import Interval
+from sympy.tensor.indexed import Indexed
+from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance,
+        density, given, independent, dependent, where, pspace, GaussianUnitaryEnsemble,
+        random_symbols, sample, Geometric, factorial_moment, Binomial, Hypergeometric,
+        DiscreteUniform, Poisson, characteristic_function, moment_generating_function,
+        BernoulliProcess, Variance, Expectation, Probability, Covariance, covariance, cmoment,
+        moment, median)
+from sympy.stats.rv import (IndependentProductPSpace, rs_swap, Density, NamedArgsMixin,
+        RandomSymbol, sample_iter, PSpace, is_random, RandomIndexedSymbol, RandomMatrixSymbol)
+from sympy.testing.pytest import raises, skip, XFAIL, warns_deprecated_sympy
+from sympy.external import import_module
+from sympy.core.numbers import comp
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.piecewise import Piecewise
+
+def test_where():
+    X, Y = Die('X'), Die('Y')
+    Z = Normal('Z', 0, 1)
+
+    assert where(Z**2 <= 1).set == Interval(-1, 1)
+    assert where(Z**2 <= 1).as_boolean() == Interval(-1, 1).as_relational(Z.symbol)
+    assert where(And(X > Y, Y > 4)).as_boolean() == And(
+        Eq(X.symbol, 6), Eq(Y.symbol, 5))
+
+    assert len(where(X < 3).set) == 2
+    assert 1 in where(X < 3).set
+
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    assert where(And(X**2 <= 1, X >= 0)).set == Interval(0, 1)
+    XX = given(X, And(X**2 <= 1, X >= 0))
+    assert XX.pspace.domain.set == Interval(0, 1)
+    assert XX.pspace.domain.as_boolean() == \
+        And(0 <= X.symbol, X.symbol**2 <= 1, -oo < X.symbol, X.symbol < oo)
+
+    with raises(TypeError):
+        XX = given(X, X + 3)
+
+
+def test_random_symbols():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+
+    assert set(random_symbols(2*X + 1)) == {X}
+    assert set(random_symbols(2*X + Y)) == {X, Y}
+    assert set(random_symbols(2*X + Y.symbol)) == {X}
+    assert set(random_symbols(2)) == set()
+
+
+def test_characteristic_function():
+    #  Imports I from sympy
+    from sympy.core.numbers import I
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1,2,7])
+    Z = Poisson('Z', 2)
+    t = symbols('_t')
+    P = Lambda(t, exp(-t**2/2))
+    Q = Lambda(t, exp(7*t*I)/3 + exp(2*t*I)/3 + exp(t*I)/3)
+    R = Lambda(t, exp(2 * exp(t*I) - 2))
+
+
+    assert characteristic_function(X).dummy_eq(P)
+    assert characteristic_function(Y).dummy_eq(Q)
+    assert characteristic_function(Z).dummy_eq(R)
+
+
+def test_moment_generating_function():
+
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1,2,7])
+    Z = Poisson('Z', 2)
+    t = symbols('_t')
+    P = Lambda(t, exp(t**2/2))
+    Q = Lambda(t, (exp(7*t)/3 + exp(2*t)/3 + exp(t)/3))
+    R = Lambda(t, exp(2 * exp(t) - 2))
+
+
+    assert moment_generating_function(X).dummy_eq(P)
+    assert moment_generating_function(Y).dummy_eq(Q)
+    assert moment_generating_function(Z).dummy_eq(R)
+
+def test_sample_iter():
+
+    X = Normal('X',0,1)
+    Y = DiscreteUniform('Y', [1, 2, 7])
+    Z = Poisson('Z', 2)
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    expr = X**2 + 3
+    iterator = sample_iter(expr)
+
+    expr2 = Y**2 + 5*Y + 4
+    iterator2 = sample_iter(expr2)
+
+    expr3 = Z**3 + 4
+    iterator3 = sample_iter(expr3)
+
+    def is_iterator(obj):
+        if (
+            hasattr(obj, '__iter__') and
+            (hasattr(obj, 'next') or
+            hasattr(obj, '__next__')) and
+            callable(obj.__iter__) and
+            obj.__iter__() is obj
+           ):
+            return True
+        else:
+            return False
+    assert is_iterator(iterator)
+    assert is_iterator(iterator2)
+    assert is_iterator(iterator3)
+
+def test_pspace():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    x = Symbol('x')
+
+    raises(ValueError, lambda: pspace(5 + 3))
+    raises(ValueError, lambda: pspace(x < 1))
+    assert pspace(X) == X.pspace
+    assert pspace(2*X + 1) == X.pspace
+    assert pspace(2*X + Y) == IndependentProductPSpace(Y.pspace, X.pspace)
+
+def test_rs_swap():
+    X = Normal('x', 0, 1)
+    Y = Exponential('y', 1)
+
+    XX = Normal('x', 0, 2)
+    YY = Normal('y', 0, 3)
+
+    expr = 2*X + Y
+    assert expr.subs(rs_swap((X, Y), (YY, XX))) == 2*XX + YY
+
+
+def test_RandomSymbol():
+
+    X = Normal('x', 0, 1)
+    Y = Normal('x', 0, 2)
+    assert X.symbol == Y.symbol
+    assert X != Y
+
+    assert X.name == X.symbol.name
+
+    X = Normal('lambda', 0, 1) # make sure we can use protected terms
+    X = Normal('Lambda', 0, 1) # make sure we can use SymPy terms
+
+
+def test_RandomSymbol_diff():
+    X = Normal('x', 0, 1)
+    assert (2*X).diff(X)
+
+
+def test_random_symbol_no_pspace():
+    x = RandomSymbol(Symbol('x'))
+    assert x.pspace == PSpace()
+
+def test_overlap():
+    X = Normal('x', 0, 1)
+    Y = Normal('x', 0, 2)
+
+    raises(ValueError, lambda: P(X > Y))
+
+
+def test_IndependentProductPSpace():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    px = X.pspace
+    py = Y.pspace
+    assert pspace(X + Y) == IndependentProductPSpace(px, py)
+    assert pspace(X + Y) == IndependentProductPSpace(py, px)
+
+
+def test_E():
+    assert E(5) == 5
+
+
+def test_H():
+    X = Normal('X', 0, 1)
+    D = Die('D', sides = 4)
+    G = Geometric('G', 0.5)
+    assert H(X, X > 0) == -log(2)/2 + S.Half + log(pi)/2
+    assert H(D, D > 2) == log(2)
+    assert comp(H(G).evalf().round(2), 1.39)
+
+
+def test_Sample():
+    X = Die('X', 6)
+    Y = Normal('Y', 0, 1)
+    z = Symbol('z', integer=True)
+
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    assert sample(X) in [1, 2, 3, 4, 5, 6]
+    assert isinstance(sample(X + Y), float)
+
+    assert P(X + Y > 0, Y < 0, numsamples=10).is_number
+    assert E(X + Y, numsamples=10).is_number
+    assert E(X**2 + Y, numsamples=10).is_number
+    assert E((X + Y)**2, numsamples=10).is_number
+    assert variance(X + Y, numsamples=10).is_number
+
+    raises(TypeError, lambda: P(Y > z, numsamples=5))
+
+    assert P(sin(Y) <= 1, numsamples=10) == 1.0
+    assert P(sin(Y) <= 1, cos(Y) < 1, numsamples=10) == 1.0
+
+    assert all(i in range(1, 7) for i in density(X, numsamples=10))
+    assert all(i in range(4, 7) for i in density(X, X>3, numsamples=10))
+
+    numpy = import_module('numpy')
+    if not numpy:
+        skip('Numpy is not installed. Abort tests')
+    #Test Issue #21563: Output of sample must be a float or array
+    assert isinstance(sample(X), (numpy.int32, numpy.int64))
+    assert isinstance(sample(Y), numpy.float64)
+    assert isinstance(sample(X, size=2), numpy.ndarray)
+
+    with warns_deprecated_sympy():
+        sample(X, numsamples=2)
+
+@XFAIL
+def test_samplingE():
+    scipy = import_module('scipy')
+    if not scipy:
+        skip('Scipy is not installed. Abort tests')
+    Y = Normal('Y', 0, 1)
+    z = Symbol('z', integer=True)
+    assert E(Sum(1/z**Y, (z, 1, oo)), Y > 2, numsamples=3).is_number
+
+
+def test_given():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    A = given(X, True)
+    B = given(X, Y > 2)
+
+    assert X == A == B
+
+
+def test_factorial_moment():
+    X = Poisson('X', 2)
+    Y = Binomial('Y', 2, S.Half)
+    Z = Hypergeometric('Z', 4, 2, 2)
+    assert factorial_moment(X, 2) == 4
+    assert factorial_moment(Y, 2) == S.Half
+    assert factorial_moment(Z, 2) == Rational(1, 3)
+
+    x, y, z, l = symbols('x y z l')
+    Y = Binomial('Y', 2, y)
+    Z = Hypergeometric('Z', 10, 2, 3)
+    assert factorial_moment(Y, l) == y**2*FallingFactorial(
+        2, l) + 2*y*(1 - y)*FallingFactorial(1, l) + (1 - y)**2*\
+            FallingFactorial(0, l)
+    assert factorial_moment(Z, l) == 7*FallingFactorial(0, l)/\
+        15 + 7*FallingFactorial(1, l)/15 + FallingFactorial(2, l)/15
+
+
+def test_dependence():
+    X, Y = Die('X'), Die('Y')
+    assert independent(X, 2*Y)
+    assert not dependent(X, 2*Y)
+
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    assert independent(X, Y)
+    assert dependent(X, 2*X)
+
+    # Create a dependency
+    XX, YY = given(Tuple(X, Y), Eq(X + Y, 3))
+    assert dependent(XX, YY)
+
+def test_dependent_finite():
+    X, Y = Die('X'), Die('Y')
+    # Dependence testing requires symbolic conditions which currently break
+    # finite random variables
+    assert dependent(X, Y + X)
+
+    XX, YY = given(Tuple(X, Y), X + Y > 5)  # Create a dependency
+    assert dependent(XX, YY)
+
+
+def test_normality():
+    X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
+    x = Symbol('x', real=True)
+    z = Symbol('z', real=True)
+    dens = density(X - Y, Eq(X + Y, z))
+
+    assert integrate(dens(x), (x, -oo, oo)) == 1
+
+
+def test_Density():
+    X = Die('X', 6)
+    d = Density(X)
+    assert d.doit() == density(X)
+
+def test_NamedArgsMixin():
+    class Foo(Basic, NamedArgsMixin):
+        _argnames = 'foo', 'bar'
+
+    a = Foo(S(1), S(2))
+
+    assert a.foo == 1
+    assert a.bar == 2
+
+    raises(AttributeError, lambda: a.baz)
+
+    class Bar(Basic, NamedArgsMixin):
+        pass
+
+    raises(AttributeError, lambda: Bar(S(1), S(2)).foo)
+
+def test_density_constant():
+    assert density(3)(2) == 0
+    assert density(3)(3) == DiracDelta(0)
+
+def test_cmoment_constant():
+    assert variance(3) == 0
+    assert cmoment(3, 3) == 0
+    assert cmoment(3, 4) == 0
+    x = Symbol('x')
+    assert variance(x) == 0
+    assert cmoment(x, 15) == 0
+    assert cmoment(x, 0) == 1
+
+def test_moment_constant():
+    assert moment(3, 0) == 1
+    assert moment(3, 1) == 3
+    assert moment(3, 2) == 9
+    x = Symbol('x')
+    assert moment(x, 2) == x**2
+
+def test_median_constant():
+    assert median(3) == 3
+    x = Symbol('x')
+    assert median(x) == x
+
+def test_real():
+    x = Normal('x', 0, 1)
+    assert x.is_real
+
+
+def test_issue_10052():
+    X = Exponential('X', 3)
+    assert P(X < oo) == 1
+    assert P(X > oo) == 0
+    assert P(X < 2, X > oo) == 0
+    assert P(X < oo, X > oo) == 0
+    assert P(X < oo, X > 2) == 1
+    assert P(X < 3, X == 2) == 0
+    raises(ValueError, lambda: P(1))
+    raises(ValueError, lambda: P(X < 1, 2))
+
+def test_issue_11934():
+    density = {0: .5, 1: .5}
+    X = FiniteRV('X', density)
+    assert E(X) == 0.5
+    assert P( X>= 2) == 0
+
+def test_issue_8129():
+    X = Exponential('X', 4)
+    assert P(X >= X) == 1
+    assert P(X > X) == 0
+    assert P(X > X+1) == 0
+
+def test_issue_12237():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    U = P(X > 0, X)
+    V = P(Y < 0, X)
+    W = P(X + Y > 0, X)
+    assert W == P(X + Y > 0, X)
+    assert U == BernoulliDistribution(S.Half, S.Zero, S.One)
+    assert V == S.Half
+
+def test_is_random():
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 1)
+    a, b = symbols('a, b')
+    G = GaussianUnitaryEnsemble('U', 2)
+    B = BernoulliProcess('B', 0.9)
+    assert not is_random(a)
+    assert not is_random(a + b)
+    assert not is_random(a * b)
+    assert not is_random(Matrix([a**2, b**2]))
+    assert is_random(X)
+    assert is_random(X**2 + Y)
+    assert is_random(Y + b**2)
+    assert is_random(Y > 5)
+    assert is_random(B[3] < 1)
+    assert is_random(G)
+    assert is_random(X * Y * B[1])
+    assert is_random(Matrix([[X, B[2]], [G, Y]]))
+    assert is_random(Eq(X, 4))
+
+def test_issue_12283():
+    x = symbols('x')
+    X = RandomSymbol(x)
+    Y = RandomSymbol('Y')
+    Z = RandomMatrixSymbol('Z', 2, 1)
+    W = RandomMatrixSymbol('W', 2, 1)
+    RI = RandomIndexedSymbol(Indexed('RI', 3))
+    assert pspace(Z) == PSpace()
+    assert pspace(RI) == PSpace()
+    assert pspace(X) == PSpace()
+    assert E(X) == Expectation(X)
+    assert P(Y > 3) == Probability(Y > 3)
+    assert variance(X) == Variance(X)
+    assert variance(RI) == Variance(RI)
+    assert covariance(X, Y) == Covariance(X, Y)
+    assert covariance(W, Z) == Covariance(W, Z)
+
+def test_issue_6810():
+    X = Die('X', 6)
+    Y = Normal('Y', 0, 1)
+    assert P(Eq(X, 2)) == S(1)/6
+    assert P(Eq(Y, 0)) == 0
+    assert P(Or(X > 2, X < 3)) == 1
+    assert P(And(X > 3, X > 2)) == S(1)/2
+
+def test_issue_20286():
+    n, p = symbols('n p')
+    B = Binomial('B', n, p)
+    k = Dummy('k', integer = True)
+    eq = Sum(Piecewise((-p**k*(1 - p)**(-k + n)*log(p**k*(1 - p)**(-k + n)*binomial(n, k))*binomial(n, k), (k >= 0) & (k <= n)), (nan, True)), (k, 0, n))
+    assert eq.dummy_eq(H(B))

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_stochastic_process.py

@@ -0,0 +1,763 @@
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.function import Lambda
+from sympy.core.numbers import (Float, Rational, oo, pi)
+from sympy.core.relational import (Eq, Ge, Gt, Le, Lt, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+from sympy.logic.boolalg import (And, Not)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.immutable import ImmutableMatrix
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (FiniteSet, Interval)
+from sympy.stats import (DiscreteMarkovChain, P, TransitionMatrixOf, E,
+                         StochasticStateSpaceOf, variance, ContinuousMarkovChain,
+                         BernoulliProcess, PoissonProcess, WienerProcess,
+                         GammaProcess, sample_stochastic_process)
+from sympy.stats.joint_rv import JointDistribution
+from sympy.stats.joint_rv_types import JointDistributionHandmade
+from sympy.stats.rv import RandomIndexedSymbol
+from sympy.stats.symbolic_probability import Probability, Expectation
+from sympy.testing.pytest import (raises, skip, ignore_warnings,
+                                  warns_deprecated_sympy)
+from sympy.external import import_module
+from sympy.stats.frv_types import BernoulliDistribution
+from sympy.stats.drv_types import PoissonDistribution
+from sympy.stats.crv_types import NormalDistribution, GammaDistribution
+from sympy.core.symbol import Str
+
+
+def test_DiscreteMarkovChain():
+
+    # pass only the name
+    X = DiscreteMarkovChain("X")
+    assert isinstance(X.state_space, Range)
+    assert X.index_set == S.Naturals0
+    assert isinstance(X.transition_probabilities, MatrixSymbol)
+    t = symbols('t', positive=True, integer=True)
+    assert isinstance(X[t], RandomIndexedSymbol)
+    assert E(X[0]) == Expectation(X[0])
+    raises(TypeError, lambda: DiscreteMarkovChain(1))
+    raises(NotImplementedError, lambda: X(t))
+    raises(NotImplementedError, lambda: X.communication_classes())
+    raises(NotImplementedError, lambda: X.canonical_form())
+    raises(NotImplementedError, lambda: X.decompose())
+
+    nz = Symbol('n', integer=True)
+    TZ = MatrixSymbol('M', nz, nz)
+    SZ = Range(nz)
+    YZ = DiscreteMarkovChain('Y', SZ, TZ)
+    assert P(Eq(YZ[2], 1), Eq(YZ[1], 0)) == TZ[0, 1]
+
+    raises(ValueError, lambda: sample_stochastic_process(t))
+    raises(ValueError, lambda: next(sample_stochastic_process(X)))
+    # pass name and state_space
+    # any hashable object should be a valid state
+    # states should be valid as a tuple/set/list/Tuple/Range
+    sym, rainy, cloudy, sunny = symbols('a Rainy Cloudy Sunny', real=True)
+    state_spaces = [(1, 2, 3), [Str('Hello'), sym, DiscreteMarkovChain("Y", (1,2,3))],
+                    Tuple(S(1), exp(sym), Str('World'), sympify=False), Range(-1, 5, 2),
+                    [rainy, cloudy, sunny]]
+    chains = [DiscreteMarkovChain("Y", state_space) for state_space in state_spaces]
+
+    for i, Y in enumerate(chains):
+        assert isinstance(Y.transition_probabilities, MatrixSymbol)
+        assert Y.state_space == state_spaces[i] or Y.state_space == FiniteSet(*state_spaces[i])
+        assert Y.number_of_states == 3
+
+        with ignore_warnings(UserWarning):  # TODO: Restore tests once warnings are removed
+            assert P(Eq(Y[2], 1), Eq(Y[0], 2), evaluate=False) == Probability(Eq(Y[2], 1), Eq(Y[0], 2))
+        assert E(Y[0]) == Expectation(Y[0])
+
+        raises(ValueError, lambda: next(sample_stochastic_process(Y)))
+
+    raises(TypeError, lambda: DiscreteMarkovChain("Y", {1: 1}))
+    Y = DiscreteMarkovChain("Y", Range(1, t, 2))
+    assert Y.number_of_states == ceiling((t-1)/2)
+
+    # pass name and transition_probabilities
+    chains = [DiscreteMarkovChain("Y", trans_probs=Matrix([])),
+              DiscreteMarkovChain("Y", trans_probs=Matrix([[0, 1], [1, 0]])),
+              DiscreteMarkovChain("Y", trans_probs=Matrix([[pi, 1-pi], [sym, 1-sym]]))]
+    for Z in chains:
+        assert Z.number_of_states == Z.transition_probabilities.shape[0]
+        assert isinstance(Z.transition_probabilities, ImmutableMatrix)
+
+    # pass name, state_space and transition_probabilities
+    T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]])
+    TS = MatrixSymbol('T', 3, 3)
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    YS = DiscreteMarkovChain("Y", ['One', 'Two', 3], TS)
+    assert Y.joint_distribution(1, Y[2], 3) == JointDistribution(Y[1], Y[2], Y[3])
+    raises(ValueError, lambda: Y.joint_distribution(Y[1].symbol, Y[2].symbol))
+    assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2)
+    assert (P(Eq(YS[3], 2), Eq(YS[1], 1)) -
+            (TS[0, 2]*TS[1, 0] + TS[1, 1]*TS[1, 2] + TS[1, 2]*TS[2, 2])).simplify() == 0
+    assert P(Eq(YS[1], 1), Eq(YS[2], 2)) == Probability(Eq(YS[1], 1))
+    assert P(Eq(YS[3], 3), Eq(YS[1], 1)) == TS[0, 2]*TS[1, 0] + TS[1, 1]*TS[1, 2] + TS[1, 2]*TS[2, 2]
+    TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]])
+    assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3)
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert E(Y[3], evaluate=False) == Expectation(Y[3])
+        assert E(Y[3], Eq(Y[2], 1)).round(2) == Float(1.1, 3)
+    TSO = MatrixSymbol('T', 4, 4)
+    raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO))))
+    raises(TypeError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], symbols('M')))
+    raises(ValueError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], MatrixSymbol('T', 3, 4)))
+    raises(ValueError, lambda: E(Y[3], Eq(Y[2], 6)))
+    raises(ValueError, lambda: E(Y[2], Eq(Y[3], 1)))
+
+
+    # extended tests for probability queries
+    TO1 = Matrix([[Rational(1, 4), Rational(3, 4), 0],[Rational(1, 3), Rational(1, 3), Rational(1, 3)],[0, Rational(1, 4), Rational(3, 4)]])
+    assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)),
+            Eq(Probability(Eq(Y[0], 0)), Rational(1, 4)) & TransitionMatrixOf(Y, TO1)) == Rational(1, 16)
+    assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), TransitionMatrixOf(Y, TO1)) == \
+            Probability(Eq(Y[0], 0))/4
+    assert P(Lt(X[1], 2) & Gt(X[1], 0), Eq(X[0], 2) &
+        StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) == Rational(1, 4)
+    assert P(Lt(X[1], 2) & Gt(X[1], 0), Eq(X[0], 2) &
+             StochasticStateSpaceOf(X, [S(0), '0', 1]) & TransitionMatrixOf(X, TO1)) == Rational(1, 4)
+    assert P(Ne(X[1], 2) & Ne(X[1], 1), Eq(X[0], 2) &
+        StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) is S.Zero
+    assert P(Ne(X[1], 2) & Ne(X[1], 1), Eq(X[0], 2) &
+             StochasticStateSpaceOf(X, [S(0), '0', 1]) & TransitionMatrixOf(X, TO1)) is S.Zero
+    assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1)) == 0.1*Probability(Eq(Y[0], 0))
+
+    # testing properties of Markov chain
+    TO2 = Matrix([[S.One, 0, 0],[Rational(1, 3), Rational(1, 3), Rational(1, 3)],[0, Rational(1, 4), Rational(3, 4)]])
+    TO3 = Matrix([[Rational(1, 4), Rational(3, 4), 0],[Rational(1, 3), Rational(1, 3), Rational(1, 3)], [0, Rational(1, 4), Rational(3, 4)]])
+    Y2 = DiscreteMarkovChain('Y', trans_probs=TO2)
+    Y3 = DiscreteMarkovChain('Y', trans_probs=TO3)
+    assert Y3.fundamental_matrix() == ImmutableMatrix([[176, 81, -132], [36, 141, -52], [-44, -39, 208]])/125
+    assert Y2.is_absorbing_chain() == True
+    assert Y3.is_absorbing_chain() == False
+    assert Y2.canonical_form() == ([0, 1, 2], TO2)
+    assert Y3.canonical_form() == ([0, 1, 2], TO3)
+    assert Y2.decompose() == ([0, 1, 2], TO2[0:1, 0:1], TO2[1:3, 0:1], TO2[1:3, 1:3])
+    assert Y3.decompose() == ([0, 1, 2], TO3, Matrix(0, 3, []), Matrix(0, 0, []))
+    TO4 = Matrix([[Rational(1, 5), Rational(2, 5), Rational(2, 5)], [Rational(1, 10), S.Half, Rational(2, 5)], [Rational(3, 5), Rational(3, 10), Rational(1, 10)]])
+    Y4 = DiscreteMarkovChain('Y', trans_probs=TO4)
+    w = ImmutableMatrix([[Rational(11, 39), Rational(16, 39), Rational(4, 13)]])
+    assert Y4.limiting_distribution == w
+    assert Y4.is_regular() == True
+    assert Y4.is_ergodic() == True
+    TS1 = MatrixSymbol('T', 3, 3)
+    Y5 = DiscreteMarkovChain('Y', trans_probs=TS1)
+    assert Y5.limiting_distribution(w, TO4).doit() == True
+    assert Y5.stationary_distribution(condition_set=True).subs(TS1, TO4).contains(w).doit() == S.true
+    TO6 = Matrix([[S.One, 0, 0, 0, 0],[S.Half, 0, S.Half, 0, 0],[0, S.Half, 0, S.Half, 0], [0, 0, S.Half, 0, S.Half], [0, 0, 0, 0, 1]])
+    Y6 = DiscreteMarkovChain('Y', trans_probs=TO6)
+    assert Y6.fundamental_matrix() == ImmutableMatrix([[Rational(3, 2), S.One, S.Half], [S.One, S(2), S.One], [S.Half, S.One, Rational(3, 2)]])
+    assert Y6.absorbing_probabilities() == ImmutableMatrix([[Rational(3, 4), Rational(1, 4)], [S.Half, S.Half], [Rational(1, 4), Rational(3, 4)]])
+    with warns_deprecated_sympy():
+        Y6.absorbing_probabilites()
+    TO7 = Matrix([[Rational(1, 2), Rational(1, 4), Rational(1, 4)], [Rational(1, 2), 0, Rational(1, 2)], [Rational(1, 4), Rational(1, 4), Rational(1, 2)]])
+    Y7 = DiscreteMarkovChain('Y', trans_probs=TO7)
+    assert Y7.is_absorbing_chain() == False
+    assert Y7.fundamental_matrix() == ImmutableMatrix([[Rational(86, 75), Rational(1, 25), Rational(-14, 75)],
+                                                            [Rational(2, 25), Rational(21, 25), Rational(2, 25)],
+                                                            [Rational(-14, 75), Rational(1, 25), Rational(86, 75)]])
+
+    # test for zero-sized matrix functionality
+    X = DiscreteMarkovChain('X', trans_probs=Matrix([]))
+    assert X.number_of_states == 0
+    assert X.stationary_distribution() == Matrix([[]])
+    assert X.communication_classes() == []
+    assert X.canonical_form() == ([], Matrix([]))
+    assert X.decompose() == ([], Matrix([]), Matrix([]), Matrix([]))
+    assert X.is_regular() == False
+    assert X.is_ergodic() == False
+
+    # test communication_class
+    # see https://drive.google.com/drive/folders/1HbxLlwwn2b3U8Lj7eb_ASIUb5vYaNIjg?usp=sharing
+    # tutorial 2.pdf
+    TO7 = Matrix([[0, 5, 5, 0, 0],
+                  [0, 0, 0, 10, 0],
+                  [5, 0, 5, 0, 0],
+                  [0, 10, 0, 0, 0],
+                  [0, 3, 0, 3, 4]])/10
+    Y7 = DiscreteMarkovChain('Y', trans_probs=TO7)
+    tuples = Y7.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([1, 3], [0, 2], [4])
+    assert recurrence == (True, False, False)
+    assert periods == (2, 1, 1)
+
+    TO8 = Matrix([[0, 0, 0, 10, 0, 0],
+                  [5, 0, 5, 0, 0, 0],
+                  [0, 4, 0, 0, 0, 6],
+                  [10, 0, 0, 0, 0, 0],
+                  [0, 10, 0, 0, 0, 0],
+                  [0, 0, 0, 5, 5, 0]])/10
+    Y8 = DiscreteMarkovChain('Y', trans_probs=TO8)
+    tuples = Y8.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([0, 3], [1, 2, 5, 4])
+    assert recurrence == (True, False)
+    assert periods == (2, 2)
+
+    TO9 = Matrix([[2, 0, 0, 3, 0, 0, 3, 2, 0, 0],
+                  [0, 10, 0, 0, 0, 0, 0, 0, 0, 0],
+                  [0, 2, 2, 0, 0, 0, 0, 0, 3, 3],
+                  [0, 0, 0, 3, 0, 0, 6, 1, 0, 0],
+                  [0, 0, 0, 0, 5, 5, 0, 0, 0, 0],
+                  [0, 0, 0, 0, 0, 10, 0, 0, 0, 0],
+                  [4, 0, 0, 5, 0, 0, 1, 0, 0, 0],
+                  [2, 0, 0, 4, 0, 0, 2, 2, 0, 0],
+                  [3, 0, 1, 0, 0, 0, 0, 0, 4, 2],
+                  [0, 0, 4, 0, 0, 0, 0, 0, 3, 3]])/10
+    Y9 = DiscreteMarkovChain('Y', trans_probs=TO9)
+    tuples = Y9.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([0, 3, 6, 7], [1], [2, 8, 9], [5], [4])
+    assert recurrence == (True, True, False, True, False)
+    assert periods == (1, 1, 1, 1, 1)
+
+    # test canonical form
+    # see https://web.archive.org/web/20201230182007/https://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf
+    # example 11.13
+    T = Matrix([[1, 0, 0, 0, 0],
+                [S(1) / 2, 0, S(1) / 2, 0, 0],
+                [0, S(1) / 2, 0, S(1) / 2, 0],
+                [0, 0, S(1) / 2, 0, S(1) / 2],
+                [0, 0, 0, 0, S(1)]])
+    DW = DiscreteMarkovChain('DW', [0, 1, 2, 3, 4], T)
+    states, A, B, C = DW.decompose()
+    assert states == [0, 4, 1, 2, 3]
+    assert A == Matrix([[1, 0], [0, 1]])
+    assert B == Matrix([[S(1)/2, 0], [0, 0], [0, S(1)/2]])
+    assert C == Matrix([[0, S(1)/2, 0], [S(1)/2, 0, S(1)/2], [0, S(1)/2, 0]])
+    states, new_matrix = DW.canonical_form()
+    assert states == [0, 4, 1, 2, 3]
+    assert new_matrix == Matrix([[1, 0, 0, 0, 0],
+                                 [0, 1, 0, 0, 0],
+                                 [S(1)/2, 0, 0, S(1)/2, 0],
+                                 [0, 0, S(1)/2, 0, S(1)/2],
+                                 [0, S(1)/2, 0, S(1)/2, 0]])
+
+    # test regular and ergodic
+    # https://web.archive.org/web/20201230182007/https://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf
+    T = Matrix([[0, 4, 0, 0, 0],
+                [1, 0, 3, 0, 0],
+                [0, 2, 0, 2, 0],
+                [0, 0, 3, 0, 1],
+                [0, 0, 0, 4, 0]])/4
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert not X.is_regular()
+    assert X.is_ergodic()
+    T = Matrix([[0, 1], [1, 0]])
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert not X.is_regular()
+    assert X.is_ergodic()
+    # http://www.math.wisc.edu/~valko/courses/331/MC2.pdf
+    T = Matrix([[2, 1, 1],
+                [2, 0, 2],
+                [1, 1, 2]])/4
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_regular()
+    assert X.is_ergodic()
+    # https://docs.ufpr.br/~lucambio/CE222/1S2014/Kemeny-Snell1976.pdf
+    T = Matrix([[1, 1], [1, 1]])/2
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_regular()
+    assert X.is_ergodic()
+
+    # test is_absorbing_chain
+    T = Matrix([[0, 1, 0],
+                [1, 0, 0],
+                [0, 0, 1]])
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert not X.is_absorbing_chain()
+    # https://en.wikipedia.org/wiki/Absorbing_Markov_chain
+    T = Matrix([[1, 1, 0, 0],
+                [0, 1, 1, 0],
+                [1, 0, 0, 1],
+                [0, 0, 0, 2]])/2
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_absorbing_chain()
+    T = Matrix([[2, 0, 0, 0, 0],
+                [1, 0, 1, 0, 0],
+                [0, 1, 0, 1, 0],
+                [0, 0, 1, 0, 1],
+                [0, 0, 0, 0, 2]])/2
+    X = DiscreteMarkovChain('X', trans_probs=T)
+    assert X.is_absorbing_chain()
+
+    # test custom state space
+    Y10 = DiscreteMarkovChain('Y', [1, 2, 3], TO2)
+    tuples = Y10.communication_classes()
+    classes, recurrence, periods = list(zip(*tuples))
+    assert classes == ([1], [2, 3])
+    assert recurrence == (True, False)
+    assert periods == (1, 1)
+    assert Y10.canonical_form() == ([1, 2, 3], TO2)
+    assert Y10.decompose() == ([1, 2, 3], TO2[0:1, 0:1], TO2[1:3, 0:1], TO2[1:3, 1:3])
+
+    # testing miscellaneous queries
+    T = Matrix([[S.Half, Rational(1, 4), Rational(1, 4)],
+                [Rational(1, 3), 0, Rational(2, 3)],
+                [S.Half, S.Half, 0]])
+    X = DiscreteMarkovChain('X', [0, 1, 2], T)
+    assert P(Eq(X[1], 2) & Eq(X[2], 1) & Eq(X[3], 0),
+    Eq(P(Eq(X[1], 0)), Rational(1, 4)) & Eq(P(Eq(X[1], 1)), Rational(1, 4))) == Rational(1, 12)
+    assert P(Eq(X[2], 1) | Eq(X[2], 2), Eq(X[1], 1)) == Rational(2, 3)
+    assert P(Eq(X[2], 1) & Eq(X[2], 2), Eq(X[1], 1)) is S.Zero
+    assert P(Ne(X[2], 2), Eq(X[1], 1)) == Rational(1, 3)
+    assert E(X[1]**2, Eq(X[0], 1)) == Rational(8, 3)
+    assert variance(X[1], Eq(X[0], 1)) == Rational(8, 9)
+    raises(ValueError, lambda: E(X[1], Eq(X[2], 1)))
+    raises(ValueError, lambda: DiscreteMarkovChain('X', [0, 1], T))
+
+    # testing miscellaneous queries with different state space
+    X = DiscreteMarkovChain('X', ['A', 'B', 'C'], T)
+    assert P(Eq(X[1], 2) & Eq(X[2], 1) & Eq(X[3], 0),
+    Eq(P(Eq(X[1], 0)), Rational(1, 4)) & Eq(P(Eq(X[1], 1)), Rational(1, 4))) == Rational(1, 12)
+    assert P(Eq(X[2], 1) | Eq(X[2], 2), Eq(X[1], 1)) == Rational(2, 3)
+    assert P(Eq(X[2], 1) & Eq(X[2], 2), Eq(X[1], 1)) is S.Zero
+    assert P(Ne(X[2], 2), Eq(X[1], 1)) == Rational(1, 3)
+    a = X.state_space.args[0]
+    c = X.state_space.args[2]
+    assert (E(X[1] ** 2, Eq(X[0], 1)) - (a**2/3 + 2*c**2/3)).simplify() == 0
+    assert (variance(X[1], Eq(X[0], 1)) - (2*(-a/3 + c/3)**2/3 + (2*a/3 - 2*c/3)**2/3)).simplify() == 0
+    raises(ValueError, lambda: E(X[1], Eq(X[2], 1)))
+
+    #testing queries with multiple RandomIndexedSymbols
+    T = Matrix([[Rational(5, 10), Rational(3, 10), Rational(2, 10)], [Rational(2, 10), Rational(7, 10), Rational(1, 10)], [Rational(3, 10), Rational(3, 10), Rational(4, 10)]])
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    assert P(Eq(Y[7], Y[5]), Eq(Y[2], 0)).round(5) == Float(0.44428, 5)
+    assert P(Gt(Y[3], Y[1]), Eq(Y[0], 0)).round(2) == Float(0.36, 2)
+    assert P(Le(Y[5], Y[10]), Eq(Y[4], 2)).round(6) == Float(0.583120, 6)
+    assert Float(P(Eq(Y[10], Y[5]), Eq(Y[4], 1)), 14) == Float(1 - P(Ne(Y[10], Y[5]), Eq(Y[4], 1)), 14)
+    assert Float(P(Gt(Y[8], Y[9]), Eq(Y[3], 2)), 14) == Float(1 - P(Le(Y[8], Y[9]), Eq(Y[3], 2)), 14)
+    assert Float(P(Lt(Y[1], Y[4]), Eq(Y[0], 0)), 14) == Float(1 - P(Ge(Y[1], Y[4]), Eq(Y[0], 0)), 14)
+    assert P(Eq(Y[5], Y[10]), Eq(Y[2], 1)) == P(Eq(Y[10], Y[5]), Eq(Y[2], 1))
+    assert P(Gt(Y[1], Y[2]), Eq(Y[0], 1)) == P(Lt(Y[2], Y[1]), Eq(Y[0], 1))
+    assert P(Ge(Y[7], Y[6]), Eq(Y[4], 1)) == P(Le(Y[6], Y[7]), Eq(Y[4], 1))
+
+    #test symbolic queries
+    a, b, c, d = symbols('a b c d')
+    T = Matrix([[Rational(1, 10), Rational(4, 10), Rational(5, 10)], [Rational(3, 10), Rational(4, 10), Rational(3, 10)], [Rational(7, 10), Rational(2, 10), Rational(1, 10)]])
+    Y = DiscreteMarkovChain("Y", [0, 1, 2], T)
+    query = P(Eq(Y[a], b), Eq(Y[c], d))
+    assert query.subs({a:10, b:2, c:5, d:1}).evalf().round(4) == P(Eq(Y[10], 2), Eq(Y[5], 1)).round(4)
+    assert query.subs({a:15, b:0, c:10, d:1}).evalf().round(4) == P(Eq(Y[15], 0), Eq(Y[10], 1)).round(4)
+    query_gt = P(Gt(Y[a], b), Eq(Y[c], d))
+    query_le = P(Le(Y[a], b), Eq(Y[c], d))
+    assert query_gt.subs({a:5, b:2, c:1, d:0}).evalf() + query_le.subs({a:5, b:2, c:1, d:0}).evalf() == 1.0
+    query_ge = P(Ge(Y[a], b), Eq(Y[c], d))
+    query_lt = P(Lt(Y[a], b), Eq(Y[c], d))
+    assert query_ge.subs({a:4, b:1, c:0, d:2}).evalf() + query_lt.subs({a:4, b:1, c:0, d:2}).evalf() == 1.0
+
+    #test issue 20078
+    assert (2*Y[1] + 3*Y[1]).simplify() == 5*Y[1]
+    assert (2*Y[1] - 3*Y[1]).simplify() == -Y[1]
+    assert (2*(0.25*Y[1])).simplify() == 0.5*Y[1]
+    assert ((2*Y[1]) * (0.25*Y[1])).simplify() == 0.5*Y[1]**2
+    assert (Y[1]**2 + Y[1]**3).simplify() == (Y[1] + 1)*Y[1]**2
+
+def test_sample_stochastic_process():
+    if not import_module('scipy'):
+        skip('SciPy Not installed. Skip sampling tests')
+    import random
+    random.seed(0)
+    numpy = import_module('numpy')
+    if numpy:
+        numpy.random.seed(0) # scipy uses numpy to sample so to set its seed
+    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)
+    for samps in range(10):
+        assert next(sample_stochastic_process(Y)) in Y.state_space
+    Z = DiscreteMarkovChain("Z", ['1', 1, 0], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(Z)) in Z.state_space
+
+    T = Matrix([[S.Half, Rational(1, 4), Rational(1, 4)],
+                [Rational(1, 3), 0, Rational(2, 3)],
+                [S.Half, S.Half, 0]])
+    X = DiscreteMarkovChain('X', [0, 1, 2], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(X)) in X.state_space
+    W = DiscreteMarkovChain('W', [1, pi, oo], T)
+    for samps in range(10):
+        assert next(sample_stochastic_process(W)) in W.state_space
+
+
+def test_ContinuousMarkovChain():
+    T1 = Matrix([[S(-2), S(2), S.Zero],
+                 [S.Zero, S.NegativeOne, S.One],
+                 [Rational(3, 2), Rational(3, 2), S(-3)]])
+    C1 = ContinuousMarkovChain('C', [0, 1, 2], T1)
+    assert C1.limiting_distribution() == ImmutableMatrix([[Rational(3, 19), Rational(12, 19), Rational(4, 19)]])
+
+    T2 = Matrix([[-S.One, S.One, S.Zero], [S.One, -S.One, S.Zero], [S.Zero, S.One, -S.One]])
+    C2 = ContinuousMarkovChain('C', [0, 1, 2], T2)
+    A, t = C2.generator_matrix, symbols('t', positive=True)
+    assert C2.transition_probabilities(A)(t) == Matrix([[S.Half + exp(-2*t)/2, S.Half - exp(-2*t)/2, 0],
+                                                       [S.Half - exp(-2*t)/2, S.Half + exp(-2*t)/2, 0],
+                                                       [S.Half - exp(-t) + exp(-2*t)/2, S.Half - exp(-2*t)/2, exp(-t)]])
+    with ignore_warnings(UserWarning): ### TODO: Restore tests once warnings are removed
+        assert P(Eq(C2(1), 1), Eq(C2(0), 1), evaluate=False) == Probability(Eq(C2(1), 1), Eq(C2(0), 1))
+    assert P(Eq(C2(1), 1), Eq(C2(0), 1)) == exp(-2)/2 + S.Half
+    assert P(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 1),
+                Eq(P(Eq(C2(1), 0)), S.Half)) == (Rational(1, 4) - exp(-2)/4)*(exp(-2)/2 + S.Half)
+    assert P(Not(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)) |
+                (Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)),
+                Eq(P(Eq(C2(1), 0)), Rational(1, 4)) & Eq(P(Eq(C2(1), 1)), Rational(1, 4))) is S.One
+    assert E(C2(Rational(3, 2)), Eq(C2(0), 2)) == -exp(-3)/2 + 2*exp(Rational(-3, 2)) + S.Half
+    assert variance(C2(Rational(3, 2)), Eq(C2(0), 1)) == ((S.Half - exp(-3)/2)**2*(exp(-3)/2 + S.Half)
+                                                    + (Rational(-1, 2) - exp(-3)/2)**2*(S.Half - exp(-3)/2))
+    raises(KeyError, lambda: P(Eq(C2(1), 0), Eq(P(Eq(C2(1), 1)), S.Half)))
+    assert P(Eq(C2(1), 0), Eq(P(Eq(C2(5), 1)), S.Half)) == Probability(Eq(C2(1), 0))
+    TS1 = MatrixSymbol('G', 3, 3)
+    CS1 = ContinuousMarkovChain('C', [0, 1, 2], TS1)
+    A = CS1.generator_matrix
+    assert CS1.transition_probabilities(A)(t) == exp(t*A)
+
+    C3 = ContinuousMarkovChain('C', [Symbol('0'), Symbol('1'), Symbol('2')], T2)
+    assert P(Eq(C3(1), 1), Eq(C3(0), 1)) == exp(-2)/2 + S.Half
+    assert P(Eq(C3(1), Symbol('1')), Eq(C3(0), Symbol('1'))) == exp(-2)/2 + S.Half
+
+    #test probability queries
+    G = Matrix([[-S(1), Rational(1, 10), Rational(9, 10)], [Rational(2, 5), -S(1), Rational(3, 5)], [Rational(1, 2), Rational(1, 2), -S(1)]])
+    C = ContinuousMarkovChain('C', state_space=[0, 1, 2], gen_mat=G)
+    assert P(Eq(C(7.385), C(3.19)), Eq(C(0.862), 0)).round(5) == Float(0.35469, 5)
+    assert P(Gt(C(98.715), C(19.807)), Eq(C(11.314), 2)).round(5) == Float(0.32452, 5)
+    assert P(Le(C(5.9), C(10.112)), Eq(C(4), 1)).round(6) == Float(0.675214, 6)
+    assert Float(P(Eq(C(7.32), C(2.91)), Eq(C(2.63), 1)), 14) == Float(1 - P(Ne(C(7.32), C(2.91)), Eq(C(2.63), 1)), 14)
+    assert Float(P(Gt(C(3.36), C(1.101)), Eq(C(0.8), 2)), 14) == Float(1 - P(Le(C(3.36), C(1.101)), Eq(C(0.8), 2)), 14)
+    assert Float(P(Lt(C(4.9), C(2.79)), Eq(C(1.61), 0)), 14) == Float(1 - P(Ge(C(4.9), C(2.79)), Eq(C(1.61), 0)), 14)
+    assert P(Eq(C(5.243), C(10.912)), Eq(C(2.174), 1)) == P(Eq(C(10.912), C(5.243)), Eq(C(2.174), 1))
+    assert P(Gt(C(2.344), C(9.9)), Eq(C(1.102), 1)) == P(Lt(C(9.9), C(2.344)), Eq(C(1.102), 1))
+    assert P(Ge(C(7.87), C(1.008)), Eq(C(0.153), 1)) == P(Le(C(1.008), C(7.87)), Eq(C(0.153), 1))
+
+    #test symbolic queries
+    a, b, c, d = symbols('a b c d')
+    query = P(Eq(C(a), b), Eq(C(c), d))
+    assert query.subs({a:3.65, b:2, c:1.78, d:1}).evalf().round(10) == P(Eq(C(3.65), 2), Eq(C(1.78), 1)).round(10)
+    query_gt = P(Gt(C(a), b), Eq(C(c), d))
+    query_le = P(Le(C(a), b), Eq(C(c), d))
+    assert query_gt.subs({a:13.2, b:0, c:3.29, d:2}).evalf() + query_le.subs({a:13.2, b:0, c:3.29, d:2}).evalf() == 1.0
+    query_ge = P(Ge(C(a), b), Eq(C(c), d))
+    query_lt = P(Lt(C(a), b), Eq(C(c), d))
+    assert query_ge.subs({a:7.43, b:1, c:1.45, d:0}).evalf() + query_lt.subs({a:7.43, b:1, c:1.45, d:0}).evalf() == 1.0
+
+    #test issue 20078
+    assert (2*C(1) + 3*C(1)).simplify() == 5*C(1)
+    assert (2*C(1) - 3*C(1)).simplify() == -C(1)
+    assert (2*(0.25*C(1))).simplify() == 0.5*C(1)
+    assert (2*C(1) * 0.25*C(1)).simplify() == 0.5*C(1)**2
+    assert (C(1)**2 + C(1)**3).simplify() == (C(1) + 1)*C(1)**2
+
+def test_BernoulliProcess():
+
+    B = BernoulliProcess("B", p=0.6, success=1, failure=0)
+    assert B.state_space == FiniteSet(0, 1)
+    assert B.index_set == S.Naturals0
+    assert B.success == 1
+    assert B.failure == 0
+
+    X = BernoulliProcess("X", p=Rational(1,3), success='H', failure='T')
+    assert X.state_space == FiniteSet('H', 'T')
+    H, T = symbols("H,T")
+    assert E(X[1]+X[2]*X[3]) == H**2/9 + 4*H*T/9 + H/3 + 4*T**2/9 + 2*T/3
+
+    t, x = symbols('t, x', positive=True, integer=True)
+    assert isinstance(B[t], RandomIndexedSymbol)
+
+    raises(ValueError, lambda: BernoulliProcess("X", p=1.1, success=1, failure=0))
+    raises(NotImplementedError, lambda: B(t))
+
+    raises(IndexError, lambda: B[-3])
+    assert B.joint_distribution(B[3], B[9]) == JointDistributionHandmade(Lambda((B[3], B[9]),
+                Piecewise((0.6, Eq(B[3], 1)), (0.4, Eq(B[3], 0)), (0, True))
+                *Piecewise((0.6, Eq(B[9], 1)), (0.4, Eq(B[9], 0)), (0, True))))
+
+    assert B.joint_distribution(2, B[4]) == JointDistributionHandmade(Lambda((B[2], B[4]),
+                Piecewise((0.6, Eq(B[2], 1)), (0.4, Eq(B[2], 0)), (0, True))
+                *Piecewise((0.6, Eq(B[4], 1)), (0.4, Eq(B[4], 0)), (0, True))))
+
+    # Test for the sum distribution of Bernoulli Process RVs
+    Y = B[1] + B[2] + B[3]
+    assert P(Eq(Y, 0)).round(2) == Float(0.06, 1)
+    assert P(Eq(Y, 2)).round(2) == Float(0.43, 2)
+    assert P(Eq(Y, 4)).round(2) == 0
+    assert P(Gt(Y, 1)).round(2) == Float(0.65, 2)
+    # Test for independency of each Random Indexed variable
+    assert P(Eq(B[1], 0) & Eq(B[2], 1) & Eq(B[3], 0) & Eq(B[4], 1)).round(2) == Float(0.06, 1)
+
+    assert E(2 * B[1] + B[2]).round(2) == Float(1.80, 3)
+    assert E(2 * B[1] + B[2] + 5).round(2) == Float(6.80, 3)
+    assert E(B[2] * B[4] + B[10]).round(2) == Float(0.96, 2)
+    assert E(B[2] > 0, Eq(B[1],1) & Eq(B[2],1)).round(2) == Float(0.60,2)
+    assert E(B[1]) == 0.6
+    assert P(B[1] > 0).round(2) == Float(0.60, 2)
+    assert P(B[1] < 1).round(2) == Float(0.40, 2)
+    assert P(B[1] > 0, B[2] <= 1).round(2) == Float(0.60, 2)
+    assert P(B[12] * B[5] > 0).round(2) == Float(0.36, 2)
+    assert P(B[12] * B[5] > 0, B[4] < 1).round(2) == Float(0.36, 2)
+    assert P(Eq(B[2], 1), B[2] > 0) == 1.0
+    assert P(Eq(B[5], 3)) == 0
+    assert P(Eq(B[1], 1), B[1] < 0) == 0
+    assert P(B[2] > 0, Eq(B[2], 1)) == 1
+    assert P(B[2] < 0, Eq(B[2], 1)) == 0
+    assert P(B[2] > 0, B[2]==7) == 0
+    assert P(B[5] > 0, B[5]) == BernoulliDistribution(0.6, 0, 1)
+    raises(ValueError, lambda: P(3))
+    raises(ValueError, lambda: P(B[3] > 0, 3))
+
+    # test issue 19456
+    expr = Sum(B[t], (t, 0, 4))
+    expr2 = Sum(B[t], (t, 1, 3))
+    expr3 = Sum(B[t]**2, (t, 1, 3))
+    assert expr.doit() == B[0] + B[1] + B[2] + B[3] + B[4]
+    assert expr2.doit() == Y
+    assert expr3.doit() == B[1]**2 + B[2]**2 + B[3]**2
+    assert B[2*t].free_symbols == {B[2*t], t}
+    assert B[4].free_symbols == {B[4]}
+    assert B[x*t].free_symbols == {B[x*t], x, t}
+
+    #test issue 20078
+    assert (2*B[t] + 3*B[t]).simplify() == 5*B[t]
+    assert (2*B[t] - 3*B[t]).simplify() == -B[t]
+    assert (2*(0.25*B[t])).simplify() == 0.5*B[t]
+    assert (2*B[t] * 0.25*B[t]).simplify() == 0.5*B[t]**2
+    assert (B[t]**2 + B[t]**3).simplify() == (B[t] + 1)*B[t]**2
+
+def test_PoissonProcess():
+    X = PoissonProcess("X", 3)
+    assert X.state_space == S.Naturals0
+    assert X.index_set == Interval(0, oo)
+    assert X.lamda == 3
+
+    t, d, x, y = symbols('t d x y', positive=True)
+    assert isinstance(X(t), RandomIndexedSymbol)
+    assert X.distribution(t) == PoissonDistribution(3*t)
+    with warns_deprecated_sympy():
+        X.distribution(X(t))
+    raises(ValueError, lambda: PoissonProcess("X", -1))
+    raises(NotImplementedError, lambda: X[t])
+    raises(IndexError, lambda: X(-5))
+
+    assert X.joint_distribution(X(2), X(3)) == JointDistributionHandmade(Lambda((X(2), X(3)),
+                6**X(2)*9**X(3)*exp(-15)/(factorial(X(2))*factorial(X(3)))))
+
+    assert X.joint_distribution(4, 6) == JointDistributionHandmade(Lambda((X(4), X(6)),
+                12**X(4)*18**X(6)*exp(-30)/(factorial(X(4))*factorial(X(6)))))
+
+    assert P(X(t) < 1) == exp(-3*t)
+    assert P(Eq(X(t), 0), Contains(t, Interval.Lopen(3, 5))) == exp(-6) # exp(-2*lamda)
+    res = P(Eq(X(t), 1), Contains(t, Interval.Lopen(3, 4)))
+    assert res == 3*exp(-3)
+
+    # Equivalent to P(Eq(X(t), 1))**4 because of non-overlapping intervals
+    assert P(Eq(X(t), 1) & Eq(X(d), 1) & Eq(X(x), 1) & Eq(X(y), 1), Contains(t, Interval.Lopen(0, 1))
+    & Contains(d, Interval.Lopen(1, 2)) & Contains(x, Interval.Lopen(2, 3))
+    & Contains(y, Interval.Lopen(3, 4))) == res**4
+
+    # Return Probability because of overlapping intervals
+    assert P(Eq(X(t), 2) & Eq(X(d), 3), Contains(t, Interval.Lopen(0, 2))
+    & Contains(d, Interval.Ropen(2, 4))) == \
+                Probability(Eq(X(d), 3) & Eq(X(t), 2), Contains(t, Interval.Lopen(0, 2))
+                & Contains(d, Interval.Ropen(2, 4)))
+
+    raises(ValueError, lambda: P(Eq(X(t), 2) & Eq(X(d), 3),
+    Contains(t, Interval.Lopen(0, 4)) & Contains(d, Interval.Lopen(3, oo)))) # no bound on d
+    assert P(Eq(X(3), 2)) == 81*exp(-9)/2
+    assert P(Eq(X(t), 2), Contains(t, Interval.Lopen(0, 5))) == 225*exp(-15)/2
+
+    # Check that probability works correctly by adding it to 1
+    res1 = P(X(t) <= 3, Contains(t, Interval.Lopen(0, 5)))
+    res2 = P(X(t) > 3, Contains(t, Interval.Lopen(0, 5)))
+    assert res1 == 691*exp(-15)
+    assert (res1 + res2).simplify() == 1
+
+    # Check Not and  Or
+    assert P(Not(Eq(X(t), 2) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) & \
+            Contains(d, Interval.Lopen(7, 8))).simplify() == -18*exp(-6) + 234*exp(-9) + 1
+    assert P(Eq(X(t), 2) | Ne(X(t), 4), Contains(t, Interval.Ropen(2, 4))) == 1 - 36*exp(-6)
+    raises(ValueError, lambda: P(X(t) > 2, X(t) + X(d)))
+    assert E(X(t)) == 3*t  # property of the distribution at a given timestamp
+    assert E(X(t)**2 + X(d)*2 + X(y)**3, Contains(t, Interval.Lopen(0, 1))
+        & Contains(d, Interval.Lopen(1, 2)) & Contains(y, Interval.Ropen(3, 4))) == 75
+    assert E(X(t)**2, Contains(t, Interval.Lopen(0, 1))) == 12
+    assert E(x*(X(t) + X(d))*(X(t)**2+X(d)**2), Contains(t, Interval.Lopen(0, 1))
+    & Contains(d, Interval.Ropen(1, 2))) == \
+            Expectation(x*(X(d) + X(t))*(X(d)**2 + X(t)**2), Contains(t, Interval.Lopen(0, 1))
+            & Contains(d, Interval.Ropen(1, 2)))
+
+    # Value Error because of infinite time bound
+    raises(ValueError, lambda: E(X(t)**3, Contains(t, Interval.Lopen(1, oo))))
+
+    # Equivalent to E(X(t)**2) - E(X(d)**2) == E(X(1)**2) - E(X(1)**2) == 0
+    assert E((X(t) + X(d))*(X(t) - X(d)), Contains(t, Interval.Lopen(0, 1))
+        & Contains(d, Interval.Lopen(1, 2))) == 0
+    assert E(X(2) + x*E(X(5))) == 15*x + 6
+    assert E(x*X(1) + y) == 3*x + y
+    assert P(Eq(X(1), 2) & Eq(X(t), 3), Contains(t, Interval.Lopen(1, 2))) == 81*exp(-6)/4
+    Y = PoissonProcess("Y", 6)
+    Z = X + Y
+    assert Z.lamda == X.lamda + Y.lamda == 9
+    raises(ValueError, lambda: X + 5) # should be added be only PoissonProcess instance
+    N, M = Z.split(4, 5)
+    assert N.lamda == 4
+    assert M.lamda == 5
+    raises(ValueError, lambda: Z.split(3, 2)) # 2+3 != 9
+
+    raises(ValueError, lambda :P(Eq(X(t), 0), Contains(t, Interval.Lopen(1, 3)) & Eq(X(1), 0)))
+    # check if it handles queries with two random variables in one args
+    res1 = P(Eq(N(3), N(5)))
+    assert res1 == P(Eq(N(t), 0), Contains(t, Interval(3, 5)))
+    res2 = P(N(3) > N(1))
+    assert res2 == P((N(t) > 0), Contains(t, Interval(1, 3)))
+    assert P(N(3) < N(1)) == 0 # condition is not possible
+    res3 = P(N(3) <= N(1)) # holds only for Eq(N(3), N(1))
+    assert res3 == P(Eq(N(t), 0), Contains(t, Interval(1, 3)))
+
+    # tests from https://www.probabilitycourse.com/chapter11/11_1_2_basic_concepts_of_the_poisson_process.php
+    X = PoissonProcess('X', 10) # 11.1
+    assert P(Eq(X(S(1)/3), 3) & Eq(X(1), 10)) == exp(-10)*Rational(8000000000, 11160261)
+    assert P(Eq(X(1), 1), Eq(X(S(1)/3), 3)) == 0
+    assert P(Eq(X(1), 10), Eq(X(S(1)/3), 3)) == P(Eq(X(S(2)/3), 7))
+
+    X = PoissonProcess('X', 2) # 11.2
+    assert P(X(S(1)/2) < 1) == exp(-1)
+    assert P(X(3) < 1, Eq(X(1), 0)) == exp(-4)
+    assert P(Eq(X(4), 3), Eq(X(2), 3)) == exp(-4)
+
+    X = PoissonProcess('X', 3)
+    assert P(Eq(X(2), 5) & Eq(X(1), 2)) == Rational(81, 4)*exp(-6)
+
+    # check few properties
+    assert P(X(2) <= 3, X(1)>=1) == 3*P(Eq(X(1), 0)) + 2*P(Eq(X(1), 1)) + P(Eq(X(1), 2))
+    assert P(X(2) <= 3, X(1) > 1) == 2*P(Eq(X(1), 0)) + 1*P(Eq(X(1), 1))
+    assert P(Eq(X(2), 5) & Eq(X(1), 2)) == P(Eq(X(1), 3))*P(Eq(X(1), 2))
+    assert P(Eq(X(3), 4), Eq(X(1), 3)) == P(Eq(X(2), 1))
+
+    #test issue 20078
+    assert (2*X(t) + 3*X(t)).simplify() == 5*X(t)
+    assert (2*X(t) - 3*X(t)).simplify() == -X(t)
+    assert (2*(0.25*X(t))).simplify() == 0.5*X(t)
+    assert (2*X(t) * 0.25*X(t)).simplify() == 0.5*X(t)**2
+    assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1)*X(t)**2
+
+def test_WienerProcess():
+    X = WienerProcess("X")
+    assert X.state_space == S.Reals
+    assert X.index_set == Interval(0, oo)
+
+    t, d, x, y = symbols('t d x y', positive=True)
+    assert isinstance(X(t), RandomIndexedSymbol)
+    assert X.distribution(t) == NormalDistribution(0, sqrt(t))
+    with warns_deprecated_sympy():
+        X.distribution(X(t))
+    raises(ValueError, lambda: PoissonProcess("X", -1))
+    raises(NotImplementedError, lambda: X[t])
+    raises(IndexError, lambda: X(-2))
+
+    assert X.joint_distribution(X(2), X(3)) == JointDistributionHandmade(
+        Lambda((X(2), X(3)), sqrt(6)*exp(-X(2)**2/4)*exp(-X(3)**2/6)/(12*pi)))
+    assert X.joint_distribution(4, 6) == JointDistributionHandmade(
+        Lambda((X(4), X(6)), sqrt(6)*exp(-X(4)**2/8)*exp(-X(6)**2/12)/(24*pi)))
+
+    assert P(X(t) < 3).simplify() == erf(3*sqrt(2)/(2*sqrt(t)))/2 + S(1)/2
+    assert P(X(t) > 2, Contains(t, Interval.Lopen(3, 7))).simplify() == S(1)/2 -\
+                erf(sqrt(2)/2)/2
+
+    # Equivalent to P(X(1)>1)**4
+    assert P((X(t) > 4) & (X(d) > 3) & (X(x) > 2) & (X(y) > 1),
+        Contains(t, Interval.Lopen(0, 1)) & Contains(d, Interval.Lopen(1, 2))
+        & Contains(x, Interval.Lopen(2, 3)) & Contains(y, Interval.Lopen(3, 4))).simplify() ==\
+        (1 - erf(sqrt(2)/2))*(1 - erf(sqrt(2)))*(1 - erf(3*sqrt(2)/2))*(1 - erf(2*sqrt(2)))/16
+
+    # Contains an overlapping interval so, return Probability
+    assert P((X(t)< 2) & (X(d)> 3), Contains(t, Interval.Lopen(0, 2))
+        & Contains(d, Interval.Ropen(2, 4))) == Probability((X(d) > 3) & (X(t) < 2),
+        Contains(d, Interval.Ropen(2, 4)) & Contains(t, Interval.Lopen(0, 2)))
+
+    assert str(P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) &
+        Contains(d, Interval.Lopen(7, 8))).simplify()) == \
+                '-(1 - erf(3*sqrt(2)/2))*(2 - erfc(5/2))/4 + 1'
+    # Distribution has mean 0 at each timestamp
+    assert E(X(t)) == 0
+    assert E(x*(X(t) + X(d))*(X(t)**2+X(d)**2), Contains(t, Interval.Lopen(0, 1))
+    & Contains(d, Interval.Ropen(1, 2))) == Expectation(x*(X(d) + X(t))*(X(d)**2 + X(t)**2),
+    Contains(d, Interval.Ropen(1, 2)) & Contains(t, Interval.Lopen(0, 1)))
+    assert E(X(t) + x*E(X(3))) == 0
+
+    #test issue 20078
+    assert (2*X(t) + 3*X(t)).simplify() == 5*X(t)
+    assert (2*X(t) - 3*X(t)).simplify() == -X(t)
+    assert (2*(0.25*X(t))).simplify() == 0.5*X(t)
+    assert (2*X(t) * 0.25*X(t)).simplify() == 0.5*X(t)**2
+    assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1)*X(t)**2
+
+
+def test_GammaProcess_symbolic():
+    t, d, x, y, g, l = symbols('t d x y g l', positive=True)
+    X = GammaProcess("X", l, g)
+
+    raises(NotImplementedError, lambda: X[t])
+    raises(IndexError, lambda: X(-1))
+    assert isinstance(X(t), RandomIndexedSymbol)
+    assert X.state_space == Interval(0, oo)
+    assert X.distribution(t) == GammaDistribution(g*t, 1/l)
+    with warns_deprecated_sympy():
+        X.distribution(X(t))
+    assert X.joint_distribution(5, X(3)) == JointDistributionHandmade(Lambda(
+        (X(5), X(3)), l**(8*g)*exp(-l*X(3))*exp(-l*X(5))*X(3)**(3*g - 1)*X(5)**(5*g
+        - 1)/(gamma(3*g)*gamma(5*g))))
+    # property of the gamma process at any given timestamp
+    assert E(X(t)) == g*t/l
+    assert variance(X(t)).simplify() == g*t/l**2
+
+    # Equivalent to E(2*X(1)) + E(X(1)**2) + E(X(1)**3), where E(X(1)) == g/l
+    assert E(X(t)**2 + X(d)*2 + X(y)**3, Contains(t, Interval.Lopen(0, 1))
+        & Contains(d, Interval.Lopen(1, 2)) & Contains(y, Interval.Ropen(3, 4))) == \
+            2*g/l + (g**2 + g)/l**2 + (g**3 + 3*g**2 + 2*g)/l**3
+
+    assert P(X(t) > 3, Contains(t, Interval.Lopen(3, 4))).simplify() == \
+                                1 - lowergamma(g, 3*l)/gamma(g) # equivalent to P(X(1)>3)
+
+
+    #test issue 20078
+    assert (2*X(t) + 3*X(t)).simplify() == 5*X(t)
+    assert (2*X(t) - 3*X(t)).simplify() == -X(t)
+    assert (2*(0.25*X(t))).simplify() == 0.5*X(t)
+    assert (2*X(t) * 0.25*X(t)).simplify() == 0.5*X(t)**2
+    assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1)*X(t)**2
+def test_GammaProcess_numeric():
+    t, d, x, y = symbols('t d x y', positive=True)
+    X = GammaProcess("X", 1, 2)
+    assert X.state_space == Interval(0, oo)
+    assert X.index_set == Interval(0, oo)
+    assert X.lamda == 1
+    assert X.gamma == 2
+
+    raises(ValueError, lambda: GammaProcess("X", -1, 2))
+    raises(ValueError, lambda: GammaProcess("X", 0, -2))
+    raises(ValueError, lambda: GammaProcess("X", -1, -2))
+
+    # all are independent because of non-overlapping intervals
+    assert P((X(t) > 4) & (X(d) > 3) & (X(x) > 2) & (X(y) > 1), Contains(t,
+        Interval.Lopen(0, 1)) & Contains(d, Interval.Lopen(1, 2)) & Contains(x,
+        Interval.Lopen(2, 3)) & Contains(y, Interval.Lopen(3, 4))).simplify() == \
+                                                            120*exp(-10)
+
+    # Check working with Not and Or
+    assert P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) &
+        Contains(d, Interval.Lopen(7, 8))).simplify() == -4*exp(-3) + 472*exp(-8)/3 + 1
+    assert P((X(t) > 2) | (X(t) < 4), Contains(t, Interval.Ropen(1, 4))).simplify() == \
+                                            -643*exp(-4)/15 + 109*exp(-2)/15 + 1
+
+    assert E(X(t)) == 2*t # E(X(t)) == gamma*t/l
+    assert E(X(2) + x*E(X(5))) == 10*x + 4

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_multivariate.py

@@ -0,0 +1,172 @@
+from sympy.stats import Expectation, Normal, Variance, Covariance
+from sympy.testing.pytest import raises
+from sympy.core.symbol import symbols
+from sympy.matrices.exceptions import ShapeError
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.stats.rv import RandomMatrixSymbol
+from sympy.stats.symbolic_multivariate_probability import (ExpectationMatrix,
+                            VarianceMatrix, CrossCovarianceMatrix)
+
+j, k = symbols("j,k")
+
+A = MatrixSymbol("A", k, k)
+B = MatrixSymbol("B", k, k)
+C = MatrixSymbol("C", k, k)
+D = MatrixSymbol("D", k, k)
+
+a = MatrixSymbol("a", k, 1)
+b = MatrixSymbol("b", k, 1)
+
+A2 = MatrixSymbol("A2", 2, 2)
+B2 = MatrixSymbol("B2", 2, 2)
+
+X = RandomMatrixSymbol("X", k, 1)
+Y = RandomMatrixSymbol("Y", k, 1)
+Z = RandomMatrixSymbol("Z", k, 1)
+W = RandomMatrixSymbol("W", k, 1)
+
+R = RandomMatrixSymbol("R", k, k)
+
+X2 = RandomMatrixSymbol("X2", 2, 1)
+
+normal = Normal("normal", 0, 1)
+
+m1 = Matrix([
+    [1, j*Normal("normal2", 2, 1)],
+    [normal, 0]
+])
+
+def test_multivariate_expectation():
+    expr = Expectation(a)
+    assert expr == Expectation(a) == ExpectationMatrix(a)
+    assert expr.expand() == a
+
+    expr = Expectation(X)
+    assert expr == Expectation(X) == ExpectationMatrix(X)
+    assert expr.shape == (k, 1)
+    assert expr.rows == k
+    assert expr.cols == 1
+    assert isinstance(expr, ExpectationMatrix)
+
+    expr = Expectation(A*X + b)
+    assert expr == ExpectationMatrix(A*X + b)
+    assert expr.expand() == A*ExpectationMatrix(X) + b
+    assert isinstance(expr, ExpectationMatrix)
+    assert expr.shape == (k, 1)
+
+    expr = Expectation(m1*X2)
+    assert expr.expand() == expr
+
+    expr = Expectation(A2*m1*B2*X2)
+    assert expr.args[0].args == (A2, m1, B2, X2)
+    assert expr.expand() == A2*ExpectationMatrix(m1*B2*X2)
+
+    expr = Expectation((X + Y)*(X - Y).T)
+    assert expr.expand() == ExpectationMatrix(X*X.T) - ExpectationMatrix(X*Y.T) +\
+                ExpectationMatrix(Y*X.T) - ExpectationMatrix(Y*Y.T)
+
+    expr = Expectation(A*X + B*Y)
+    assert expr.expand() == A*ExpectationMatrix(X) + B*ExpectationMatrix(Y)
+
+    assert Expectation(m1).doit() == Matrix([[1, 2*j], [0, 0]])
+
+    x1 = Matrix([
+    [Normal('N11', 11, 1), Normal('N12', 12, 1)],
+    [Normal('N21', 21, 1), Normal('N22', 22, 1)]
+    ])
+    x2 = Matrix([
+    [Normal('M11', 1, 1), Normal('M12', 2, 1)],
+    [Normal('M21', 3, 1), Normal('M22', 4, 1)]
+    ])
+
+    assert Expectation(Expectation(x1 + x2)).doit(deep=False) == ExpectationMatrix(x1 + x2)
+    assert Expectation(Expectation(x1 + x2)).doit() == Matrix([[12, 14], [24, 26]])
+
+
+def test_multivariate_variance():
+    raises(ShapeError, lambda: Variance(A))
+
+    expr = Variance(a)
+    assert expr == Variance(a) == VarianceMatrix(a)
+    assert expr.expand() == ZeroMatrix(k, k)
+    expr = Variance(a.T)
+    assert expr == Variance(a.T) == VarianceMatrix(a.T)
+    assert expr.expand() == ZeroMatrix(k, k)
+
+    expr = Variance(X)
+    assert expr == Variance(X) == VarianceMatrix(X)
+    assert expr.shape == (k, k)
+    assert expr.rows == k
+    assert expr.cols == k
+    assert isinstance(expr, VarianceMatrix)
+
+    expr = Variance(A*X)
+    assert expr == VarianceMatrix(A*X)
+    assert expr.expand() == A*VarianceMatrix(X)*A.T
+    assert isinstance(expr, VarianceMatrix)
+    assert expr.shape == (k, k)
+
+    expr = Variance(A*B*X)
+    assert expr.expand() == A*B*VarianceMatrix(X)*B.T*A.T
+
+    expr = Variance(m1*X2)
+    assert expr.expand() == expr
+
+    expr = Variance(A2*m1*B2*X2)
+    assert expr.args[0].args == (A2, m1, B2, X2)
+    assert expr.expand() == expr
+
+    expr = Variance(A*X + B*Y)
+    assert expr.expand() == 2*A*CrossCovarianceMatrix(X, Y)*B.T +\
+                    A*VarianceMatrix(X)*A.T + B*VarianceMatrix(Y)*B.T
+
+def test_multivariate_crosscovariance():
+    raises(ShapeError, lambda: Covariance(X, Y.T))
+    raises(ShapeError, lambda: Covariance(X, A))
+
+
+    expr = Covariance(a.T, b.T)
+    assert expr.shape == (1, 1)
+    assert expr.expand() == ZeroMatrix(1, 1)
+
+    expr = Covariance(a, b)
+    assert expr == Covariance(a, b) == CrossCovarianceMatrix(a, b)
+    assert expr.expand() == ZeroMatrix(k, k)
+    assert expr.shape == (k, k)
+    assert expr.rows == k
+    assert expr.cols == k
+    assert isinstance(expr, CrossCovarianceMatrix)
+
+    expr = Covariance(A*X + a, b)
+    assert expr.expand() == ZeroMatrix(k, k)
+
+    expr = Covariance(X, Y)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == expr
+
+    expr = Covariance(X, X)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == VarianceMatrix(X)
+
+    expr = Covariance(X + Y, Z)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == CrossCovarianceMatrix(X, Z) + CrossCovarianceMatrix(Y, Z)
+
+    expr = Covariance(A*X, Y)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == A*CrossCovarianceMatrix(X, Y)
+
+    expr = Covariance(X, B*Y)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == CrossCovarianceMatrix(X, Y)*B.T
+
+    expr = Covariance(A*X + a, B.T*Y + b)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == A*CrossCovarianceMatrix(X, Y)*B
+
+    expr = Covariance(A*X + B*Y + a, C.T*Z + D.T*W + b)
+    assert isinstance(expr, CrossCovarianceMatrix)
+    assert expr.expand() == A*CrossCovarianceMatrix(X, W)*D + A*CrossCovarianceMatrix(X, Z)*C \
+        + B*CrossCovarianceMatrix(Y, W)*D + B*CrossCovarianceMatrix(Y, Z)*C

.venv/lib/python3.12/site-packages/sympy/stats/tests/test_symbolic_probability.py

@@ -0,0 +1,175 @@
+from sympy.concrete.summations import Sum
+from sympy.core.mul import Mul
+from sympy.core.numbers import (oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import Integral
+from sympy.core.expr import unchanged
+from sympy.stats import (Normal, Poisson, variance, Covariance, Variance,
+                         Probability, Expectation, Moment, CentralMoment)
+from sympy.stats.rv import probability, expectation
+
+
+def test_literal_probability():
+    X = Normal('X', 2, 3)
+    Y = Normal('Y', 3, 4)
+    Z = Poisson('Z', 4)
+    W = Poisson('W', 3)
+    x = symbols('x', real=True)
+    y, w, z = symbols('y, w, z')
+
+    assert Probability(X > 0).evaluate_integral() == probability(X > 0)
+    assert Probability(X > x).evaluate_integral() == probability(X > x)
+    assert Probability(X > 0).rewrite(Integral).doit() == probability(X > 0)
+    assert Probability(X > x).rewrite(Integral).doit() == probability(X > x)
+
+    assert Expectation(X).evaluate_integral() == expectation(X)
+    assert Expectation(X).rewrite(Integral).doit() == expectation(X)
+    assert Expectation(X**2).evaluate_integral() == expectation(X**2)
+    assert Expectation(x*X).args == (x*X,)
+    assert Expectation(x*X).expand() == x*Expectation(X)
+    assert Expectation(2*X + 3*Y + z*X*Y).expand() == 2*Expectation(X) + 3*Expectation(Y) + z*Expectation(X*Y)
+    assert Expectation(2*X + 3*Y + z*X*Y).args == (2*X + 3*Y + z*X*Y,)
+    assert Expectation(sin(X)) == Expectation(sin(X)).expand()
+    assert Expectation(2*x*sin(X)*Y + y*X**2 + z*X*Y).expand() == 2*x*Expectation(sin(X)*Y) \
+                            + y*Expectation(X**2) + z*Expectation(X*Y)
+    assert Expectation(X + Y).expand() ==  Expectation(X) + Expectation(Y)
+    assert Expectation((X + Y)*(X - Y)).expand() == Expectation(X**2) - Expectation(Y**2)
+    assert Expectation((X + Y)*(X - Y)).expand().doit() == -12
+    assert Expectation(X + Y, evaluate=True).doit() == 5
+    assert Expectation(X + Expectation(Y)).doit() == 5
+    assert Expectation(X + Expectation(Y)).doit(deep=False) == 2 + Expectation(Expectation(Y))
+    assert Expectation(X + Expectation(Y + Expectation(2*X))).doit(deep=False) == 2 \
+                                + Expectation(Expectation(Y + Expectation(2*X)))
+    assert Expectation(X + Expectation(Y + Expectation(2*X))).doit() == 9
+    assert Expectation(Expectation(2*X)).doit() == 4
+    assert Expectation(Expectation(2*X)).doit(deep=False) == Expectation(2*X)
+    assert Expectation(4*Expectation(2*X)).doit(deep=False) == 4*Expectation(2*X)
+    assert Expectation((X + Y)**3).expand() == 3*Expectation(X*Y**2) +\
+                3*Expectation(X**2*Y) + Expectation(X**3) + Expectation(Y**3)
+    assert Expectation((X - Y)**3).expand() == 3*Expectation(X*Y**2) -\
+                3*Expectation(X**2*Y) + Expectation(X**3) - Expectation(Y**3)
+    assert Expectation((X - Y)**2).expand() == -2*Expectation(X*Y) +\
+                Expectation(X**2) + Expectation(Y**2)
+
+    assert Variance(w).args == (w,)
+    assert Variance(w).expand() == 0
+    assert Variance(X).evaluate_integral() == Variance(X).rewrite(Integral).doit() == variance(X)
+    assert Variance(X + z).args == (X + z,)
+    assert Variance(X + z).expand() == Variance(X)
+    assert Variance(X*Y).args == (Mul(X, Y),)
+    assert type(Variance(X*Y)) == Variance
+    assert Variance(z*X).expand() == z**2*Variance(X)
+    assert Variance(X + Y).expand() == Variance(X) + Variance(Y) + 2*Covariance(X, Y)
+    assert Variance(X + Y + Z + W).expand() == (Variance(X) + Variance(Y) + Variance(Z) + Variance(W) +
+                                       2 * Covariance(X, Y) + 2 * Covariance(X, Z) + 2 * Covariance(X, W) +
+                                       2 * Covariance(Y, Z) + 2 * Covariance(Y, W) + 2 * Covariance(W, Z))
+    assert Variance(X**2).evaluate_integral() == variance(X**2)
+    assert unchanged(Variance, X**2)
+    assert Variance(x*X**2).expand() == x**2*Variance(X**2)
+    assert Variance(sin(X)).args == (sin(X),)
+    assert Variance(sin(X)).expand() == Variance(sin(X))
+    assert Variance(x*sin(X)).expand() == x**2*Variance(sin(X))
+
+    assert Covariance(w, z).args == (w, z)
+    assert Covariance(w, z).expand() == 0
+    assert Covariance(X, w).expand() == 0
+    assert Covariance(w, X).expand() == 0
+    assert Covariance(X, Y).args == (X, Y)
+    assert type(Covariance(X, Y)) == Covariance
+    assert Covariance(z*X + 3, Y).expand() == z*Covariance(X, Y)
+    assert Covariance(X, X).args == (X, X)
+    assert Covariance(X, X).expand() == Variance(X)
+    assert Covariance(z*X + 3, w*Y + 4).expand() == w*z*Covariance(X,Y)
+    assert Covariance(X, Y) == Covariance(Y, X)
+    assert Covariance(X + Y, Z + W).expand() == Covariance(W, X) + Covariance(W, Y) + Covariance(X, Z) + Covariance(Y, Z)
+    assert Covariance(x*X + y*Y, z*Z + w*W).expand() == (x*w*Covariance(W, X) + w*y*Covariance(W, Y) +
+                                                x*z*Covariance(X, Z) + y*z*Covariance(Y, Z))
+    assert Covariance(x*X**2 + y*sin(Y), z*Y*Z**2 + w*W).expand() == (w*x*Covariance(W, X**2) + w*y*Covariance(sin(Y), W) +
+                                                        x*z*Covariance(Y*Z**2, X**2) + y*z*Covariance(Y*Z**2, sin(Y)))
+    assert Covariance(X, X**2).expand() == Covariance(X, X**2)
+    assert Covariance(X, sin(X)).expand() == Covariance(sin(X), X)
+    assert Covariance(X**2, sin(X)*Y).expand() == Covariance(sin(X)*Y, X**2)
+    assert Covariance(w, X).evaluate_integral() == 0
+
+
+def test_probability_rewrite():
+    X = Normal('X', 2, 3)
+    Y = Normal('Y', 3, 4)
+    Z = Poisson('Z', 4)
+    W = Poisson('W', 3)
+    x, y, w, z = symbols('x, y, w, z')
+
+    assert Variance(w).rewrite(Expectation) == 0
+    assert Variance(X).rewrite(Expectation) == Expectation(X ** 2) - Expectation(X) ** 2
+    assert Variance(X, condition=Y).rewrite(Expectation) == Expectation(X ** 2, Y) - Expectation(X, Y) ** 2
+    assert Variance(X, Y) != Expectation(X**2) - Expectation(X)**2
+    assert Variance(X + z).rewrite(Expectation) == Expectation((X + z) ** 2) - Expectation(X + z) ** 2
+    assert Variance(X * Y).rewrite(Expectation) == Expectation(X ** 2 * Y ** 2) - Expectation(X * Y) ** 2
+
+    assert Covariance(w, X).rewrite(Expectation) == -w*Expectation(X) + Expectation(w*X)
+    assert Covariance(X, Y).rewrite(Expectation) == Expectation(X*Y) - Expectation(X)*Expectation(Y)
+    assert Covariance(X, Y, condition=W).rewrite(Expectation) == Expectation(X * Y, W) - Expectation(X, W) * Expectation(Y, W)
+
+    w, x, z = symbols("W, x, z")
+    px = Probability(Eq(X, x))
+    pz = Probability(Eq(Z, z))
+
+    assert Expectation(X).rewrite(Probability) == Integral(x*px, (x, -oo, oo))
+    assert Expectation(Z).rewrite(Probability) == Sum(z*pz, (z, 0, oo))
+    assert Variance(X).rewrite(Probability) == Integral(x**2*px, (x, -oo, oo)) - Integral(x*px, (x, -oo, oo))**2
+    assert Variance(Z).rewrite(Probability) == Sum(z**2*pz, (z, 0, oo)) - Sum(z*pz, (z, 0, oo))**2
+    assert Covariance(w, X).rewrite(Probability) == \
+           -w*Integral(x*Probability(Eq(X, x)), (x, -oo, oo)) + Integral(w*x*Probability(Eq(X, x)), (x, -oo, oo))
+
+    # To test rewrite as sum function
+    assert Variance(X).rewrite(Sum) == Variance(X).rewrite(Integral)
+    assert Expectation(X).rewrite(Sum) == Expectation(X).rewrite(Integral)
+
+    assert Covariance(w, X).rewrite(Sum) == 0
+
+    assert Covariance(w, X).rewrite(Integral) == 0
+
+    assert Variance(X, condition=Y).rewrite(Probability) == Integral(x**2*Probability(Eq(X, x), Y), (x, -oo, oo)) - \
+                                                            Integral(x*Probability(Eq(X, x), Y), (x, -oo, oo))**2
+
+
+def test_symbolic_Moment():
+    mu = symbols('mu', real=True)
+    sigma = symbols('sigma', positive=True)
+    x = symbols('x')
+    X = Normal('X', mu, sigma)
+    M = Moment(X, 4, 2)
+    assert M.rewrite(Expectation) == Expectation((X - 2)**4)
+    assert M.rewrite(Probability) == Integral((x - 2)**4*Probability(Eq(X, x)),
+                                    (x, -oo, oo))
+    k = Dummy('k')
+    expri = Integral(sqrt(2)*(k - 2)**4*exp(-(k - \
+                mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (k, -oo, oo))
+    assert M.rewrite(Integral).dummy_eq(expri)
+    assert M.doit() == (mu**4 - 8*mu**3 + 6*mu**2*sigma**2 + \
+                24*mu**2 - 24*mu*sigma**2 - 32*mu + 3*sigma**4 + 24*sigma**2 + 16)
+    M = Moment(2, 5)
+    assert M.doit() == 2**5
+
+
+def test_symbolic_CentralMoment():
+    mu = symbols('mu', real=True)
+    sigma = symbols('sigma', positive=True)
+    x = symbols('x')
+    X = Normal('X', mu, sigma)
+    CM = CentralMoment(X, 6)
+    assert CM.rewrite(Expectation) == Expectation((X - Expectation(X))**6)
+    assert CM.rewrite(Probability) == Integral((x - Integral(x*Probability(True),
+                    (x, -oo, oo)))**6*Probability(Eq(X, x)), (x, -oo, oo))
+    k = Dummy('k')
+    expri = Integral(sqrt(2)*(k - Integral(sqrt(2)*k*exp(-(k - \
+        mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (k, -oo, oo)))**6*exp(-(k - \
+        mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (k, -oo, oo))
+    assert CM.rewrite(Integral).dummy_eq(expri)
+    assert CM.doit().simplify() == 15*sigma**6
+    CM = Moment(5, 5)
+    assert CM.doit() == 5**5

.venv/lib/python3.12/site-packages/sympy/strategies/__init__.py

@@ -0,0 +1,50 @@
+""" Rewrite Rules
+
+DISCLAIMER: This module is experimental. The interface is subject to change.
+
+A rule is a function that transforms one expression into another
+
+    Rule :: Expr -> Expr
+
+A strategy is a function that says how a rule should be applied to a syntax
+tree. In general strategies take rules and produce a new rule
+
+    Strategy :: [Rules], Other-stuff -> Rule
+
+This allows developers to separate a mathematical transformation from the
+algorithmic details of applying that transformation. The goal is to separate
+the work of mathematical programming from algorithmic programming.
+
+Submodules
+
+strategies.rl         - some fundamental rules
+strategies.core       - generic non-SymPy specific strategies
+strategies.traverse   - strategies that traverse a SymPy tree
+strategies.tools      - some conglomerate strategies that do depend on SymPy
+"""
+
+from . import rl
+from . import traverse
+from .rl import rm_id, unpack, flatten, sort, glom, distribute, rebuild
+from .util import new
+from .core import (
+    condition, debug, chain, null_safe, do_one, exhaust, minimize, tryit)
+from .tools import canon, typed
+from . import branch
+
+__all__ = [
+    'rl',
+
+    'traverse',
+
+    'rm_id', 'unpack', 'flatten', 'sort', 'glom', 'distribute', 'rebuild',
+
+    'new',
+
+    'condition', 'debug', 'chain', 'null_safe', 'do_one', 'exhaust',
+    'minimize', 'tryit',
+
+    'canon', 'typed',
+
+    'branch',
+]

.venv/lib/python3.12/site-packages/sympy/strategies/branch/__init__.py

@@ -0,0 +1,14 @@
+from . import traverse
+from .core import (
+    condition, debug, multiplex, exhaust, notempty,
+    chain, onaction, sfilter, yieldify, do_one, identity)
+from .tools import canon
+
+__all__ = [
+    'traverse',
+
+    'condition', 'debug', 'multiplex', 'exhaust', 'notempty', 'chain',
+    'onaction', 'sfilter', 'yieldify', 'do_one', 'identity',
+
+    'canon',
+]

.venv/lib/python3.12/site-packages/sympy/strategies/branch/core.py

@@ -0,0 +1,116 @@
+""" Generic SymPy-Independent Strategies """
+
+
+def identity(x):
+    yield x
+
+
+def exhaust(brule):
+    """ Apply a branching rule repeatedly until it has no effect """
+    def exhaust_brl(expr):
+        seen = {expr}
+        for nexpr in brule(expr):
+            if nexpr not in seen:
+                seen.add(nexpr)
+                yield from exhaust_brl(nexpr)
+        if seen == {expr}:
+            yield expr
+    return exhaust_brl
+
+
+def onaction(brule, fn):
+    def onaction_brl(expr):
+        for result in brule(expr):
+            if result != expr:
+                fn(brule, expr, result)
+            yield result
+    return onaction_brl
+
+
+def debug(brule, file=None):
+    """ Print the input and output expressions at each rule application """
+    if not file:
+        from sys import stdout
+        file = stdout
+
+    def write(brl, expr, result):
+        file.write("Rule: %s\n" % brl.__name__)
+        file.write("In: %s\nOut: %s\n\n" % (expr, result))
+
+    return onaction(brule, write)
+
+
+def multiplex(*brules):
+    """ Multiplex many branching rules into one """
+    def multiplex_brl(expr):
+        seen = set()
+        for brl in brules:
+            for nexpr in brl(expr):
+                if nexpr not in seen:
+                    seen.add(nexpr)
+                    yield nexpr
+    return multiplex_brl
+
+
+def condition(cond, brule):
+    """ Only apply branching rule if condition is true """
+    def conditioned_brl(expr):
+        if cond(expr):
+            yield from brule(expr)
+        else:
+            pass
+    return conditioned_brl
+
+
+def sfilter(pred, brule):
+    """ Yield only those results which satisfy the predicate """
+    def filtered_brl(expr):
+        yield from filter(pred, brule(expr))
+    return filtered_brl
+
+
+def notempty(brule):
+    def notempty_brl(expr):
+        yielded = False
+        for nexpr in brule(expr):
+            yielded = True
+            yield nexpr
+        if not yielded:
+            yield expr
+    return notempty_brl
+
+
+def do_one(*brules):
+    """ Execute one of the branching rules """
+    def do_one_brl(expr):
+        yielded = False
+        for brl in brules:
+            for nexpr in brl(expr):
+                yielded = True
+                yield nexpr
+            if yielded:
+                return
+    return do_one_brl
+
+
+def chain(*brules):
+    """
+    Compose a sequence of brules so that they apply to the expr sequentially
+    """
+    def chain_brl(expr):
+        if not brules:
+            yield expr
+            return
+
+        head, tail = brules[0], brules[1:]
+        for nexpr in head(expr):
+            yield from chain(*tail)(nexpr)
+
+    return chain_brl
+
+
+def yieldify(rl):
+    """ Turn a rule into a branching rule """
+    def brl(expr):
+        yield rl(expr)
+    return brl